QXmlStreamReaderPrivate Class Reference

#include <qxmlstream_p.h>

Inheritance diagram for QXmlStreamReaderPrivate:

Classes
struct	Attribute
struct	DtdAttribute
struct	Entity
struct	EntityDeclaration
struct	NotationDeclaration
struct	Value

Public Functions
void	checkPublicLiteral (const QStringRef &publicId)
bool	checkStartDocument ()
void	clearSym ()
void	clearTextBuffer ()
void	consumeRule (int)
bool	entitiesMustBeDeclared () const
int	fastScanContentCharList ()
	Used for text nodes essentially. More...
int	fastScanLiteralContent ()
int	fastScanName (int *prefix=0)
int	fastScanNMTOKEN ()
int	fastScanSpace ()
uint	filterCarriageReturn ()
uint	getChar ()
ushort	getChar_helper ()
void	init ()
void	injectToken (ushort tokenToInject)
QStringRef	namespaceForPrefix (const QStringRef &prefix)
bool	parse ()
void	parseEntity (const QString &value)
void	parseError ()
uint	peekChar ()
void	putChar (uint c)
void	putChar (QChar c)
void	putReplacement (const QString &s)
void	putReplacementInAttributeValue (const QString &s)
void	putString (const QString &s, int from=0)
void	putStringLiteral (const QString &s)
	QXmlStreamReaderPrivate (QXmlStreamReader *q)
void	raiseError (QXmlStreamReader::Error error, const QString &message=QString())
void	raiseWellFormedError (const QString &message)
void	reallocateStack ()
bool	referenceEntity (Entity &entity)
uint	resolveCharRef (int symbolIndex)
void	resolveDtd ()
void	resolvePublicNamespaces ()
void	resolveTag ()
QString	resolveUndeclaredEntity (const QString &name)
void	resume (int rule)
bool	scanAfterDefaultDecl ()
bool	scanAfterLangleBang ()
bool	scanAttType ()
bool	scanNData ()
bool	scanPublicOrSystem ()
bool	scanString (const char *str, short tokenToInject, bool requireSpace=true)
bool	scanUntil (const char *str, short tokenToInject=-1)
	Scans characters until str is encountered, and validates the characters as according to the Char[2] production and do the line-ending normalization. More...
void	startDocument ()
Value &	sym (int index) const
QStringRef	symName (int index)
QStringRef	symName (const Value &symbol)
QStringRef	symPrefix (int index)
QStringRef	symPrefix (const Value &symbol)
QStringRef	symString (int index)
QStringRef	symString (int index, int offset)
QStringRef	symString (const Value &symbol)
void	write (const QString &)
void	write (const char *)
	~QXmlStreamReaderPrivate ()
Public Functions inherited from QXmlStreamPrivateTagStack
QStringRef	addToStringStorage (const QStringRef &s)
QStringRef	addToStringStorage (const QString &s)
	QXmlStreamPrivateTagStack ()
Tag &	tagStack_pop ()
Tag &	tagStack_push ()

Public Variables
bool	atEnd
QXmlStreamAttributes	attributes
QXmlStreamSimpleStack< Attribute >	attributeStack
qint64	characterOffset
QTextCodec *	codec
QByteArray	dataBuffer
QTextDecoder *	decoder
bool	deleteDevice
QIODevice *	device
QStringRef	documentEncoding
QStringRef	documentVersion
QXmlStreamSimpleStack< DtdAttribute >	dtdAttributes
QStringRef	dtdName
QStringRef	dtdPublicId
QStringRef	dtdSystemId
QXmlStreamSimpleStack< EntityDeclaration >	entityDeclarations
QHash< QString, Entity >	entityHash
QXmlStreamReaderPrivate *	entityParser
QXmlStreamSimpleStack< Entity * >	entityReferenceStack
QXmlStreamEntityResolver *	entityResolver
QXmlStreamReader::Error	error
QString	errorString
uchar	firstByte
uint	hasCheckedStartDocument: 1
uint	hasExternalDtdSubset: 1
uint	hasSeenTag: 1
uint	inParseEntity: 1
uint	isCDATA: 1
uint	isEmptyElement: 1
uint	isWhitespace: 1
bool	lastAttributeIsCData
QStringRef	lastAttributeValue
qint64	lastLineStart
qint64	lineNumber
uint	lockEncoding: 1
QStringRef	name
uint	namespaceProcessing: 1
QStringRef	namespaceUri
qint64	nbytesread
uint	normalizeLiterals: 1
QXmlStreamSimpleStack< NotationDeclaration >	notationDeclarations
QHash< QString, Entity >	parameterEntityHash
QStringRef	prefix
QStringRef	processingInstructionData
QStringRef	processingInstructionTarget
QXmlStreamEntityDeclarations	publicEntityDeclarations
QXmlStreamNamespaceDeclarations	publicNamespaceDeclarations
QXmlStreamNotationDeclarations	publicNotationDeclarations
QXmlStreamSimpleStack< uint >	putStack
QStringRef	qualifiedName
QByteArray	rawReadBuffer
QString	readBuffer
int	readBufferPos
uint	referenceToParameterEntityDetected: 1
uint	referenceToUnparsedEntityDetected: 1
int	resumeReduction
bool	scanDtd
int	stack_size
uint	standalone: 1
int *	state_stack
Value *	sym_stack
QStringRef	text
QString	textBuffer
short	token
ushort	token_char
int	tos
QXmlStreamReader::TokenType	type
QString	unresolvedEntity
Public Variables inherited from QXmlStreamPrivateTagStack
QXmlStreamSimpleStack< NamespaceDeclaration >	namespaceDeclarations
bool	tagsDone
QXmlStreamSimpleStack< Tag >	tagStack
QString	tagStackStringStorage
int	tagStackStringStorageSize

Private Functions
void	setType (const QXmlStreamReader::TokenType t)
	Never assign to variable type directly. More...

Properties
QXmlStreamReader *	q_ptr

Additional Inherited Members
Public Types inherited from QXmlStreamReader_Table
enum	VariousConstants {   EOF_SYMBOL = 0, AMPERSAND = 5, ANY = 41, ATTLIST = 31,   BANG = 25, CDATA = 47, CDATA_START = 28, COLON = 17,   COMMA = 19, DASH = 20, DBLQUOTE = 8, DIGIT = 27,   DOCTYPE = 29, DOT = 23, ELEMENT = 30, EMPTY = 40,   ENTITIES = 51, ENTITY = 32, ENTITY_DONE = 45, EQ = 14,   ERROR = 43, FIXED = 39, HASH = 6, ID = 48,   IDREF = 49, IDREFS = 50, IMPLIED = 38, LANGLE = 3,   LBRACK = 9, LETTER = 26, LPAREN = 11, NDATA = 36,   NMTOKEN = 52, NMTOKENS = 53, NOTATION = 33, NOTOKEN = 1,   PARSE_ENTITY = 44, PCDATA = 42, PERCENT = 15, PIPE = 13,   PLUS = 21, PUBLIC = 35, QUESTIONMARK = 24, QUOTE = 7,   RANGLE = 4, RBRACK = 10, REQUIRED = 37, RPAREN = 12,   SEMICOLON = 18, SHIFT_THERE = 56, SLASH = 16, SPACE = 2,   STAR = 22, SYSTEM = 34, UNRESOLVED_ENTITY = 46, VERSION = 55,   XML = 54, ACCEPT_STATE = 416, RULE_COUNT = 270, STATE_COUNT = 427,   TERMINAL_COUNT = 57, NON_TERMINAL_COUNT = 84, GOTO_INDEX_OFFSET = 427, GOTO_INFO_OFFSET = 1017,   GOTO_CHECK_OFFSET = 1017 }
Static Public Functions inherited from QXmlStreamReader_Table
static int	nt_action (int state, int nt)
static int	t_action (int state, int token)
Static Public Variables inherited from QXmlStreamReader_Table
static const short	action_check []
static const short	action_default []
static const short	action_index []
static const short	action_info []
static const short	goto_default []
static const short	lhs []
static const short	rhs []
static const char *const	spell []

Detailed Description

Definition at line 742 of file qxmlstream_p.h.

Constructors and Destructors

QXmlStreamReaderPrivate()

QXmlStreamReaderPrivate::QXmlStreamReaderPrivate

(

QXmlStreamReader *

q

)

Definition at line 819 of file qxmlstream.cpp.

Referenced by parseEntity().

    :q_ptr(q)
{
    device = 0;
    deleteDevice = false;
#ifndef QT_NO_TEXTCODEC
    decoder = 0;
#endif
    stack_size = 64;
    sym_stack = 0;
    state_stack = 0;
    reallocateStack();
    entityResolver = 0;
    init();
    entityHash.insert(QLatin1String("lt"), Entity::createLiteral(QLatin1String("<")));
    entityHash.insert(QLatin1String("gt"), Entity::createLiteral(QLatin1String(">")));
    entityHash.insert(QLatin1String("amp"), Entity::createLiteral(QLatin1String("&")));
    entityHash.insert(QLatin1String("apos"), Entity::createLiteral(QLatin1String("'")));
    entityHash.insert(QLatin1String("quot"), Entity::createLiteral(QLatin1String("\"")));
}

~QXmlStreamReaderPrivate()

QXmlStreamReaderPrivate::~QXmlStreamReaderPrivate

(

)

Definition at line 927 of file qxmlstream.cpp.

{
#ifndef QT_NO_TEXTCODEC
    delete decoder;
#endif
    qFree(sym_stack);
    qFree(state_stack);
    delete entityParser;
}

Functions

checkPublicLiteral()

void QXmlStreamReaderPrivate::checkPublicLiteral

(

const QStringRef &

publicId

)

Definition at line 1765 of file qxmlstream.cpp.

{
//#x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]

    const ushort *data = reinterpret_cast<const ushort *>(publicId.constData());
    uchar c = 0;
    int i;
    for (i = publicId.size() - 1; i >= 0; --i) {
        if (data[i] < 256)
            switch ((c = data[i])) {
            case ' ': case '\n': case '\r': case '-': case '(': case ')':
            case '+': case ',': case '.': case '/': case ':': case '=':
            case '?': case ';': case '!': case '*': case '#': case '@':
            case '$': case '_': case '%': case '\'': case '\"':
                continue;
            default:
                if ((c >= 'a' && c <= 'z')
                    || (c >= 'A' && c <= 'Z')
                    || (c >= '0' && c <= '9'))
                    continue;
            }
        break;
    }
    if (i >= 0)
        raiseWellFormedError(QXmlStream::tr("Unexpected character '%1' in public id literal.").arg(QChar(QLatin1Char(c))));
}

checkStartDocument()

bool QXmlStreamReaderPrivate::checkStartDocument

(

)

Definition at line 1797 of file qxmlstream.cpp.

{
    hasCheckedStartDocument = true;

    if (scanString(spell[XML], XML))
        return true;

    type = QXmlStreamReader::StartDocument;
    if (atEnd) {
        hasCheckedStartDocument = false;
        raiseError(QXmlStreamReader::PrematureEndOfDocumentError);
    }
    return false;
}

clearSym()

void QXmlStreamReaderPrivate::clearSym ( )

inline

Definition at line 950 of file qxmlstream_p.h.

{ Value &val = sym(1); val.pos = textBuffer.size(); val.len = 0; }

clearTextBuffer()

void QXmlStreamReaderPrivate::clearTextBuffer ( )

inline

Definition at line 908 of file qxmlstream_p.h.

                                  {
        if (!scanDtd) {
            textBuffer.resize(0);
            textBuffer.reserve(256);
        }
    }

consumeRule()

void QXmlStreamReaderPrivate::consumeRule ( int  )

inline

entitiesMustBeDeclared()

bool QXmlStreamReaderPrivate::entitiesMustBeDeclared ( ) const

inline

Definition at line 884 of file qxmlstream_p.h.

                                               {
        return (!inParseEntity
                && (standalone
                    || (!referenceToUnparsedEntityDetected
                        && !referenceToParameterEntityDetected // Errata 13 as of 2006-04-25
                        && !hasExternalDtdSubset)));
    }

fastScanContentCharList()

int QXmlStreamReaderPrivate::fastScanContentCharList ( )

inline

Used for text nodes essentially.

Warning

This function is not part of the public interface.

That is, characters appearing inside elements.

Definition at line 1263 of file qxmlstream.cpp.

{
    int n = 0;
    uint c;
    while ((c = getChar())) {
        switch (ushort(c)) {
        case 0xfffe:
        case 0xffff:
        case 0:
            putChar(c);
            return n;
        case ']': {
            isWhitespace = false;
            int pos = textBuffer.size();
            textBuffer += QChar(ushort(c));
            ++n;
            while ((c = getChar()) == ']') {
                textBuffer += QChar(ushort(c));
                ++n;
            }
            if (c == 0) {
                putString(textBuffer, pos);
                textBuffer.resize(pos);
            } else if (c == '>' && textBuffer.at(textBuffer.size()-2) == QLatin1Char(']')) {
                raiseWellFormedError(QXmlStream::tr("Sequence ']]>' not allowed in content."));
            } else {
                putChar(c);
                break;
            }
            return n;
        } break;
        case '\r':
            if ((c = filterCarriageReturn()) == 0)
                return n;
            // fall through
        case '\n':
            ++lineNumber;
            lastLineStart = characterOffset + readBufferPos;
            // fall through
        case ' ':
        case '\t':
            textBuffer += QChar(ushort(c));
            ++n;
            break;
        case '&':
        case '<':
            if (!(c & 0xff0000)) {
                putChar(c);
                return n;
            }
            // fall through
        default:
            if (c < 0x20) {
                putChar(c);
                return n;
            }
            isWhitespace = false;
            textBuffer += QChar(ushort(c));
            ++n;
        }
    }
    return n;
}

fastScanLiteralContent()

int QXmlStreamReaderPrivate::fastScanLiteralContent ( )

inline

Warning

This function is not part of the public interface.

Scan strings with quotes or apostrophes surround them. For instance, attributes, the version and encoding field in the XML prolog and entity declarations.

If normalizeLiterals is set to true, the function also normalizes whitespace. It is set to true when the first start tag is encountered.

Definition at line 1181 of file qxmlstream.cpp.

{
    int n = 0;
    uint c;
    while ((c = getChar())) {
        switch (ushort(c)) {
        case 0xfffe:
        case 0xffff:
        case 0:
            /* The putChar() call is necessary so the parser re-gets
             * the character from the input source, when raising an error. */
            putChar(c);
            return n;
        case '\r':
            if (filterCarriageReturn() == 0)
                return n;
            // fall through
        case '\n':
            ++lineNumber;
            lastLineStart = characterOffset + readBufferPos;
            // fall through
        case ' ':
        case '\t':
            if (normalizeLiterals)
                textBuffer += QLatin1Char(' ');
            else
                textBuffer += QChar(c);
            ++n;
            break;
        case '&':
        case '<':
        case '\"':
        case '\'':
            if (!(c & 0xff0000)) {
                putChar(c);
                return n;
            }
            // fall through
        default:
            textBuffer += QChar(c);
            ++n;
        }
    }
    return n;
}

fastScanName()

int QXmlStreamReaderPrivate::fastScanName ( int *  prefix = 0 )

inline

Definition at line 1327 of file qxmlstream.cpp.

{
    int n = 0;
    ushort c;
    while ((c = getChar())) {
        switch (c) {
        case '\n':
        case ' ':
        case '\t':
        case '\r':
        case '&':
        case '#':
        case '\'':
        case '\"':
        case '<':
        case '>':
        case '[':
        case ']':
        case '=':
        case '%':
        case '/':
        case ';':
        case '?':
        case '!':
        case '^':
        case '|':
        case ',':
        case '(':
        case ')':
        case '+':
        case '*':
            putChar(c);
            if (prefix && *prefix == n+1) {
                *prefix = 0;
                putChar(':');
                --n;
            }
            return n;
        case ':':
            if (prefix) {
                if (*prefix == 0) {
                    *prefix = n+2;
                } else { // only one colon allowed according to the namespace spec.
                    putChar(c);
                    return n;
                }
            } else {
                putChar(c);
                return n;
            }
            // fall through
        default:
            textBuffer += QChar(c);
            ++n;
        }
    }

    if (prefix)
        *prefix = 0;
    int pos = textBuffer.size() - n;
    putString(textBuffer, pos);
    textBuffer.resize(pos);
    return 0;
}

fastScanNMTOKEN()

int QXmlStreamReaderPrivate::fastScanNMTOKEN ( )

inline

Definition at line 1443 of file qxmlstream.cpp.

{
    int n = 0;
    uint c;
    while ((c = getChar())) {
        if (fastDetermineNameChar(c) == NotName) {
            putChar(c);
            return n;
        } else {
            ++n;
            textBuffer += QChar(c);
        }
    }

    int pos = textBuffer.size() - n;
    putString(textBuffer, pos);
    textBuffer.resize(pos);

    return n;
}

fastScanSpace()

int QXmlStreamReaderPrivate::fastScanSpace ( )

inline

Definition at line 1227 of file qxmlstream.cpp.

Referenced by scanNData(), and scanString().

{
    int n = 0;
    ushort c;
    while ((c = getChar())) {
        switch (c) {
        case '\r':
            if ((c = filterCarriageReturn()) == 0)
                return n;
            // fall through
        case '\n':
            ++lineNumber;
            lastLineStart = characterOffset + readBufferPos;
            // fall through
        case ' ':
        case '\t':
            textBuffer += QChar(c);
            ++n;
            break;
        default:
            putChar(c);
            return n;
        }
    }
    return n;
}

filterCarriageReturn()

uint QXmlStreamReaderPrivate::filterCarriageReturn ( )

inline

Definition at line 938 of file qxmlstream.cpp.

Referenced by fastScanContentCharList(), fastScanLiteralContent(), fastScanSpace(), and scanUntil().

{
    uint peekc = peekChar();
    if (peekc == '\n') {
        if (putStack.size())
            putStack.pop();
        else
            ++readBufferPos;
        return peekc;
    }
    if (peekc == 0) {
        putChar('\r');
        return 0;
    }
    return '\n';
}

getChar()

uint QXmlStreamReaderPrivate::getChar ( )

inline

Warning

This function is not part of the public interface. If the end of the file is encountered, 0 is returned.

Definition at line 959 of file qxmlstream.cpp.

Referenced by fastScanContentCharList(), fastScanLiteralContent(), fastScanName(), fastScanNMTOKEN(), fastScanSpace(), scanString(), and scanUntil().

{
    uint c;
    if (putStack.size()) {
        c = atEnd ? 0 : putStack.pop();
    } else {
        if (readBufferPos < readBuffer.size())
            c = readBuffer.at(readBufferPos++).unicode();
        else
            c = getChar_helper();
    }

    return c;
}

getChar_helper()

ushort QXmlStreamReaderPrivate::getChar_helper

(

)

Definition at line 1503 of file qxmlstream.cpp.

Referenced by getChar(), and peekChar().

{
    const int BUFFER_SIZE = 8192;
    characterOffset += readBufferPos;
    readBufferPos = 0;
    readBuffer.resize(0);
#ifndef QT_NO_TEXTCODEC
    if (decoder)
#endif
        nbytesread = 0;
    if (device) {
        rawReadBuffer.resize(BUFFER_SIZE);
        int nbytesreadOrMinus1 = device->read(rawReadBuffer.data() + nbytesread, BUFFER_SIZE - nbytesread);
        nbytesread += qMax(nbytesreadOrMinus1, 0);
    } else {
        if (nbytesread)
            rawReadBuffer += dataBuffer;
        else
            rawReadBuffer = dataBuffer;
        nbytesread = rawReadBuffer.size();
        dataBuffer.clear();
    }
    if (!nbytesread) {
        atEnd = true;
        return 0;
    }

#ifndef QT_NO_TEXTCODEC
    if (!decoder) {
        if (nbytesread < 4) { // the 4 is to cover 0xef 0xbb 0xbf plus
                              // one extra for the utf8 codec
            atEnd = true;
            return 0;
        }
        int mib = 106; // UTF-8

        // look for byte order mark
        uchar ch1 = rawReadBuffer.at(0);
        uchar ch2 = rawReadBuffer.at(1);
        uchar ch3 = rawReadBuffer.at(2);
        uchar ch4 = rawReadBuffer.at(3);

        if ((ch1 == 0 && ch2 == 0 && ch3 == 0xfe && ch4 == 0xff) ||
            (ch1 == 0xff && ch2 == 0xfe && ch3 == 0 && ch4 == 0))
            mib = 1017; // UTF-32 with byte order mark
        else if (ch1 == 0x3c && ch2 == 0x00 && ch3 == 0x00 && ch4 == 0x00)
            mib = 1019; // UTF-32LE
        else if (ch1 == 0x00 && ch2 == 0x00 && ch3 == 0x00 && ch4 == 0x3c)
            mib = 1018; // UTF-32BE
        else if ((ch1 == 0xfe && ch2 == 0xff) || (ch1 == 0xff && ch2 == 0xfe))
            mib = 1015; // UTF-16 with byte order mark
        else if (ch1 == 0x3c && ch2 == 0x00)
            mib = 1014; // UTF-16LE
        else if (ch1 == 0x00 && ch2 == 0x3c)
            mib = 1013; // UTF-16BE
        codec = QTextCodec::codecForMib(mib);
        Q_ASSERT(codec);
        decoder = codec->makeDecoder();
    }

    decoder->toUnicode(&readBuffer, rawReadBuffer.constData(), nbytesread);

    if(lockEncoding && decoder->hasFailure()) {
        raiseWellFormedError(QXmlStream::tr("Encountered incorrectly encoded content."));
        readBuffer.clear();
        return 0;
    }
#else
    readBuffer = QString::fromLatin1(rawReadBuffer.data(), nbytesread);
#endif // QT_NO_TEXTCODEC

    readBuffer.reserve(1); // keep capacity when calling resize() next time

    if (readBufferPos < readBuffer.size()) {
        ushort c = readBuffer.at(readBufferPos++).unicode();
        return c;
    }

    atEnd = true;
    return 0;
}

init()

void QXmlStreamReaderPrivate::init

(

)

Definition at line 840 of file qxmlstream.cpp.

Referenced by parseEntity(), and QXmlStreamReaderPrivate().

{
    tos = 0;
    scanDtd = false;
    token = -1;
    token_char = 0;
    isEmptyElement = false;
    isWhitespace = true;
    isCDATA = false;
    standalone = false;
    tos = 0;
    resumeReduction = 0;
    state_stack[tos++] = 0;
    state_stack[tos] = 0;
    putStack.clear();
    putStack.reserve(32);
    textBuffer.clear();
    textBuffer.reserve(256);
    tagStack.clear();
    tagsDone = false;
    attributes.clear();
    attributes.reserve(16);
    lineNumber = lastLineStart = characterOffset = 0;
    readBufferPos = 0;
    nbytesread = 0;
#ifndef QT_NO_TEXTCODEC
    codec = QTextCodec::codecForMib(106); // utf8
    delete decoder;
    decoder = 0;
#endif
    attributeStack.clear();
    attributeStack.reserve(16);
    entityParser = 0;
    hasCheckedStartDocument = false;
    normalizeLiterals = false;
    hasSeenTag = false;
    atEnd = false;
    inParseEntity = false;
    referenceToUnparsedEntityDetected = false;
    referenceToParameterEntityDetected = false;
    hasExternalDtdSubset = false;
    lockEncoding = false;
    namespaceProcessing = true;
    rawReadBuffer.clear();
    dataBuffer.clear();
    readBuffer.clear();

    type = QXmlStreamReader::NoToken;
    error = QXmlStreamReader::NoError;
}

injectToken()

void QXmlStreamReaderPrivate::injectToken ( ushort  tokenToInject )

inline

Definition at line 969 of file qxmlstream_p.h.

Referenced by parseEntity(), scanString(), and scanUntil().

                                                  {
        putChar(int(tokenToInject) << 16);
    }

namespaceForPrefix()

QStringRef QXmlStreamReaderPrivate::namespaceForPrefix

(

const QStringRef &

prefix

)

Definition at line 1585 of file qxmlstream.cpp.

Referenced by resolveTag().

{
     for (int j = namespaceDeclarations.size() - 1; j >= 0; --j) {
         const NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.at(j);
         if (namespaceDeclaration.prefix == prefix) {
             return namespaceDeclaration.namespaceUri;
         }
     }

#if 1
     if (namespaceProcessing && !prefix.isEmpty())
         raiseWellFormedError(QXmlStream::tr("Namespace prefix '%1' not declared").arg(prefix.toString()));
#endif

     return QStringRef();
}

parse()

bool QXmlStreamReaderPrivate::parse

(

)

Definition at line 1017 of file qxmlstream_p.h.

Referenced by parseEntity().

{
    // cleanup currently reported token

    switch (type) {
    case QXmlStreamReader::StartElement:
        name.clear();
        prefix.clear();
    qualifiedName.clear();
        namespaceUri.clear();
        if (publicNamespaceDeclarations.size())
            publicNamespaceDeclarations.clear();
        if (attributes.size())
            attributes.resize(0);
        if (isEmptyElement) {
            setType(QXmlStreamReader::EndElement);
            Tag &tag = tagStack_pop();
            namespaceUri = tag.namespaceDeclaration.namespaceUri;
            name = tag.name;
        qualifiedName = tag.qualifiedName;
            isEmptyElement = false;
            return true;
        }
        clearTextBuffer();
        break;
    case QXmlStreamReader::EndElement:
        name.clear();
        prefix.clear();
    qualifiedName.clear();
        namespaceUri.clear();
        clearTextBuffer();
        break;
    case QXmlStreamReader::DTD:
        publicNotationDeclarations.clear();
        publicEntityDeclarations.clear();
        dtdName.clear();
        dtdPublicId.clear();
        dtdSystemId.clear();
        // fall through
    case QXmlStreamReader::Comment:
    case QXmlStreamReader::Characters:
        isCDATA = false;
    isWhitespace = true;
        text.clear();
        clearTextBuffer();
        break;
    case QXmlStreamReader::EntityReference:
        text.clear();
        name.clear();
        clearTextBuffer();
        break;
    case QXmlStreamReader::ProcessingInstruction:
        processingInstructionTarget.clear();
        processingInstructionData.clear();
    clearTextBuffer();
        break;
    case QXmlStreamReader::NoToken:
    case QXmlStreamReader::Invalid:
        break;
    case QXmlStreamReader::StartDocument:
    lockEncoding = true;
        documentVersion.clear();
        documentEncoding.clear();
#ifndef QT_NO_TEXTCODEC
    if(decoder->hasFailure()) {
        raiseWellFormedError(QXmlStream::tr("Encountered incorrectly encoded content."));
        readBuffer.clear();
        return false;
    }
#endif
        // fall through
    default:
        clearTextBuffer();
        ;
    }

    setType(QXmlStreamReader::NoToken);


    // the main parse loop
    int act, r;

    if (resumeReduction) {
        act = state_stack[tos-1];
        r = resumeReduction;
        resumeReduction = 0;
        goto ResumeReduction;
    }

    act = state_stack[tos];

    forever {
        if (token == -1 && - TERMINAL_COUNT != action_index[act]) {
            uint cu = getChar();
            token = NOTOKEN;
            token_char = cu;
            if (cu & 0xff0000) {
                token = cu >> 16;
            } else switch (token_char) {
            case 0xfffe:
            case 0xffff:
                token = ERROR;
                break;
            case '\r':
                token = SPACE;
                if (cu == '\r') {
                    if ((token_char = filterCarriageReturn())) {
                        ++lineNumber;
                        lastLineStart = characterOffset + readBufferPos;
                        break;
                    }
                } else {
                    break;
                }
                // fall through
            case '\0': {
                token = EOF_SYMBOL;
                if (!tagsDone && !inParseEntity) {
                    int a = t_action(act, token);
                    if (a < 0) {
                        raiseError(QXmlStreamReader::PrematureEndOfDocumentError);
                        return false;
                    }
                }

            } break;
            case '\n':
                ++lineNumber;
                lastLineStart = characterOffset + readBufferPos;
            case ' ':
            case '\t':
                token = SPACE;
                break;
            case '&':
                token = AMPERSAND;
                break;
            case '#':
                token = HASH;
                break;
            case '\'':
                token = QUOTE;
                break;
            case '\"':
                token = DBLQUOTE;
                break;
            case '<':
                token = LANGLE;
                break;
            case '>':
                token = RANGLE;
                break;
            case '[':
                token = LBRACK;
                break;
            case ']':
                token = RBRACK;
                break;
            case '(':
                token = LPAREN;
                break;
            case ')':
                token = RPAREN;
                break;
            case '|':
                token = PIPE;
                break;
            case '=':
                token = EQ;
                break;
            case '%':
                token = PERCENT;
                break;
            case '/':
                token = SLASH;
                break;
            case ':':
                token = COLON;
                break;
            case ';':
                token = SEMICOLON;
                break;
            case ',':
                token = COMMA;
                break;
            case '-':
                token = DASH;
                break;
            case '+':
                token = PLUS;
                break;
            case '*':
                token = STAR;
                break;
            case '.':
                token = DOT;
                break;
            case '?':
                token = QUESTIONMARK;
                break;
            case '!':
                token = BANG;
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                token = DIGIT;
                break;
            default:
                if (cu < 0x20)
                    token = NOTOKEN;
                else
                    token = LETTER;
                break;
            }
        }

        act = t_action (act, token);
        if (act == ACCEPT_STATE) {
            // reset the parser in case someone resumes (process instructions can follow a valid document)
            tos = 0;
            state_stack[tos++] = 0;
            state_stack[tos] = 0;
            return true;
        } else if (act > 0) {
            if (++tos == stack_size-1)
                reallocateStack();

            Value &val = sym_stack[tos];
            val.c = token_char;
            val.pos = textBuffer.size();
            val.prefix = 0;
            val.len = 1;
            if (token_char)
                textBuffer += QChar(token_char);

            state_stack[tos] = act;
            token = -1;


        } else if (act < 0) {
            r = - act - 1;

#if defined (QLALR_DEBUG)
            int ridx = rule_index[r];
            printf ("%3d) %s ::=", r + 1, spell[rule_info[ridx]]);
            ++ridx;
            for (int i = ridx; i < ridx + rhs[r]; ++i) {
                int symbol = rule_info[i];
                if (const char *name = spell[symbol])
                    printf (" %s", name);
                else
                    printf (" #%d", symbol);
            }
            printf ("\n");
#endif

            tos -= rhs[r];
            act = state_stack[tos++];
        ResumeReduction:
            switch (r) {

        case 0:
            setType(QXmlStreamReader::EndDocument);
        break;

        case 1:
            if (type != QXmlStreamReader::Invalid) {
                if (hasSeenTag || inParseEntity) {
                    setType(QXmlStreamReader::EndDocument);
                } else {
                    raiseError(QXmlStreamReader::NotWellFormedError, QXmlStream::tr("Start tag expected."));
                    // reset the parser
                    tos = 0;
                    state_stack[tos++] = 0;
                    state_stack[tos] = 0;
                    return false;
                }
            }
        break;

        case 10:
            entityReferenceStack.pop()->isCurrentlyReferenced = false;
            clearSym();
        break;

        case 11:
            if (!scanString(spell[VERSION], VERSION, false) && atEnd) {
                resume(11);
                return false;
            }
        break;

        case 12:
            setType(QXmlStreamReader::StartDocument);
            documentVersion = symString(6);
            startDocument();
        break;

        case 13:
            hasExternalDtdSubset = true;
            dtdSystemId = symString(2);
        break;

        case 14:
            checkPublicLiteral(symString(2));
            dtdPublicId = symString(2);
            dtdSystemId = symString(4);
            hasExternalDtdSubset = true;
        break;

        case 16:
            if (!scanPublicOrSystem() && atEnd) {
                resume(16);
                return false;
            }
            dtdName = symString(3);
        break;

        case 17:
        case 18:
            dtdName = symString(3);
            // fall through

        case 19:
        case 20:
            setType(QXmlStreamReader::DTD);
            text = &textBuffer;
        break;

        case 21:
            scanDtd = true;
        break;

        case 22:
            scanDtd = false;
        break;

        case 37:
            if (!scanString(spell[EMPTY], EMPTY, false)
                && !scanString(spell[ANY], ANY, false)
                && atEnd) {
                resume(37);
                return false;
            }
        break;

        case 43:
            if (!scanString(spell[PCDATA], PCDATA, false) && atEnd) {
                resume(43);
                return false;
            }
        break;

        case 68: {
            lastAttributeIsCData = true;
        } break;

        case 78:
            if (!scanAfterDefaultDecl() && atEnd) {
                resume(78);
                return false;
            }
        break;

        case 83:
                sym(1) = sym(2);
                lastAttributeValue.clear();
                lastAttributeIsCData = false;
                if (!scanAttType() && atEnd) {
                    resume(83);
                    return false;
                }
        break;

        case 84: {
            DtdAttribute &dtdAttribute = dtdAttributes.push();
            dtdAttribute.tagName.clear();
            dtdAttribute.isCDATA = lastAttributeIsCData;
            dtdAttribute.attributePrefix = addToStringStorage(symPrefix(1));
            dtdAttribute.attributeName = addToStringStorage(symString(1));
            dtdAttribute.attributeQualifiedName = addToStringStorage(symName(1));
            dtdAttribute.isNamespaceAttribute = (dtdAttribute.attributePrefix == QLatin1String("xmlns")
                                                 || (dtdAttribute.attributePrefix.isEmpty()
                                                     && dtdAttribute.attributeName == QLatin1String("xmlns")));
            if (lastAttributeValue.isNull()) {
                dtdAttribute.defaultValue.clear();
            } else {
                if (dtdAttribute.isCDATA)
                    dtdAttribute.defaultValue = addToStringStorage(lastAttributeValue);
                else
                    dtdAttribute.defaultValue = addToStringStorage(lastAttributeValue.toString().simplified());

            }
        } break;

        case 88: {
            if (referenceToUnparsedEntityDetected && !standalone)
                break;
            int n = dtdAttributes.size();
            QStringRef tagName = addToStringStorage(symName(3));
            while (n--) {
                DtdAttribute &dtdAttribute = dtdAttributes[n];
                if (!dtdAttribute.tagName.isNull())
                    break;
                dtdAttribute.tagName = tagName;
                for (int i = 0; i < n; ++i) {
                    if ((dtdAttributes[i].tagName.isNull() || dtdAttributes[i].tagName == tagName)
                        && dtdAttributes[i].attributeQualifiedName == dtdAttribute.attributeQualifiedName) {
                        dtdAttribute.attributeQualifiedName.clear(); // redefined, delete it
                        break;
                    }
                }
            }
        } break;

        case 89: {
            if (!scanPublicOrSystem() && atEnd) {
                resume(89);
                return false;
            }
            EntityDeclaration &entityDeclaration = entityDeclarations.push();
            entityDeclaration.clear();
            entityDeclaration.name = symString(3);
        } break;

        case 90: {
            if (!scanPublicOrSystem() && atEnd) {
                resume(90);
                return false;
            }
            EntityDeclaration &entityDeclaration = entityDeclarations.push();
            entityDeclaration.clear();
            entityDeclaration.name = symString(5);
            entityDeclaration.parameter = true;
        } break;

        case 91: {
            if (!scanNData() && atEnd) {
                resume(91);
                return false;
            }
            EntityDeclaration &entityDeclaration = entityDeclarations.top();
            entityDeclaration.systemId = symString(3);
            entityDeclaration.external = true;
        } break;

        case 92: {
            if (!scanNData() && atEnd) {
                resume(92);
                return false;
            }
            EntityDeclaration &entityDeclaration = entityDeclarations.top();
            checkPublicLiteral((entityDeclaration.publicId = symString(3)));
            entityDeclaration.systemId = symString(5);
            entityDeclaration.external = true;
        } break;

        case 93: {
            EntityDeclaration &entityDeclaration = entityDeclarations.top();
            entityDeclaration.notationName = symString(3);
            if (entityDeclaration.parameter)
                raiseWellFormedError(QXmlStream::tr("NDATA in parameter entity declaration."));
        }
        //fall through

        case 94:
        case 95: {
            if (referenceToUnparsedEntityDetected && !standalone) {
                entityDeclarations.pop();
                break;
            }
            EntityDeclaration &entityDeclaration = entityDeclarations.top();
            if (!entityDeclaration.external)
                entityDeclaration.value = symString(2);
            QString entityName = entityDeclaration.name.toString();
            QHash<QString, Entity> &hash = entityDeclaration.parameter ? parameterEntityHash : entityHash;
            if (!hash.contains(entityName)) {
                Entity entity(entityDeclaration.value.toString());
                entity.unparsed = (!entityDeclaration.notationName.isNull());
                entity.external = entityDeclaration.external;
                hash.insert(entityName, entity);
            }
        } break;

        case 96: {
            setType(QXmlStreamReader::ProcessingInstruction);
            int pos = sym(4).pos + sym(4).len;
            processingInstructionTarget = symString(3);
            if (scanUntil("?>")) {
                processingInstructionData = QStringRef(&textBuffer, pos, textBuffer.size() - pos - 2);
                const QString piTarget(processingInstructionTarget.toString());
                if (!piTarget.compare(QLatin1String("xml"), Qt::CaseInsensitive)) {
                    raiseWellFormedError(QXmlStream::tr("XML declaration not at start of document."));
                }
                else if(!QXmlUtils::isNCName(piTarget))
                    raiseWellFormedError(QXmlStream::tr("%1 is an invalid processing instruction name.").arg(piTarget));
            } else if (type != QXmlStreamReader::Invalid){
                resume(96);
                return false;
            }
        } break;

        case 97:
            setType(QXmlStreamReader::ProcessingInstruction);
            processingInstructionTarget = symString(3);
            if (!processingInstructionTarget.toString().compare(QLatin1String("xml"), Qt::CaseInsensitive))
                raiseWellFormedError(QXmlStream::tr("Invalid processing instruction name."));
        break;

        case 98:
            if (!scanAfterLangleBang() && atEnd) {
                resume(98);
                return false;
            }
        break;

        case 99:
            if (!scanUntil("--")) {
                resume(99);
                return false;
            }
        break;

        case 100: {
            setType(QXmlStreamReader::Comment);
            int pos = sym(1).pos + 4;
            text = QStringRef(&textBuffer, pos, textBuffer.size() - pos - 3);
        } break;

        case 101: {
            setType(QXmlStreamReader::Characters);
            isCDATA = true;
        isWhitespace = false;
            int pos = sym(2).pos;
            if (scanUntil("]]>", -1)) {
                text = QStringRef(&textBuffer, pos, textBuffer.size() - pos - 3);
            } else {
                resume(101);
                return false;
            }
        } break;

        case 102: {
            if (!scanPublicOrSystem() && atEnd) {
                resume(102);
                return false;
            }
            NotationDeclaration &notationDeclaration = notationDeclarations.push();
            notationDeclaration.name = symString(3);
        } break;

        case 103: {
            NotationDeclaration &notationDeclaration = notationDeclarations.top();
            notationDeclaration.systemId = symString(3);
            notationDeclaration.publicId.clear();
        } break;

        case 104: {
            NotationDeclaration &notationDeclaration = notationDeclarations.top();
            notationDeclaration.systemId.clear();
            checkPublicLiteral((notationDeclaration.publicId = symString(3)));
        } break;

        case 105: {
            NotationDeclaration &notationDeclaration = notationDeclarations.top();
            checkPublicLiteral((notationDeclaration.publicId = symString(3)));
            notationDeclaration.systemId = symString(5);
        } break;

        case 129:
            isWhitespace = false;
            // fall through

        case 130:
            sym(1).len += fastScanContentCharList();
            if (atEnd && !inParseEntity) {
                resume(130);
                return false;
            }
    break;

        case 139:
        if (!textBuffer.isEmpty()) {
                setType(QXmlStreamReader::Characters);
                text = &textBuffer;
        }
    break;

        case 140:
        case 141:
            clearSym();
        break;

        case 142:
        case 143:
            sym(1) = sym(2);
        break;

        case 144:
        case 145:
        case 146:
        case 147:
            sym(1).len += sym(2).len;
        break;

        case 173:
        if (normalizeLiterals)
                textBuffer.data()[textBuffer.size()-1] = QLatin1Char(' ');
        break;

        case 174:
            sym(1).len += fastScanLiteralContent();
            if (atEnd) {
                resume(174);
                return false;
            }
        break;

        case 175: {
            if (!QXmlUtils::isPublicID(symString(1).toString())) {
                raiseWellFormedError(QXmlStream::tr("%1 is an invalid PUBLIC identifier.").arg(symString(1).toString()));
                resume(175);
                return false;
            }
        } break;

        case 176:
        case 177:
            clearSym();
        break;

        case 178:
        case 179:
        sym(1) = sym(2);
        break;

        case 180:
        case 181:
        case 182:
        case 183:
            sym(1).len += sym(2).len;
        break;

        case 213:
        case 214:
            clearSym();
        break;

        case 215:
        case 216:
            sym(1) = sym(2);
            lastAttributeValue = symString(1);
        break;

        case 217:
        case 218:
        case 219:
        case 220:
            sym(1).len += sym(2).len;
        break;

        case 229: {
            QStringRef prefix = symPrefix(1);
            if (prefix.isEmpty() && symString(1) == QLatin1String("xmlns") && namespaceProcessing) {
                NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();
                namespaceDeclaration.prefix.clear();

                const QStringRef ns(symString(5));
                if(ns == QLatin1String("http://www.w3.org/2000/xmlns/") ||
                   ns == QLatin1String("http://www.w3.org/XML/1998/namespace"))
                    raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));
                else
                    namespaceDeclaration.namespaceUri = addToStringStorage(ns);
            } else {
                Attribute &attribute = attributeStack.push();
                attribute.key = sym(1);
                attribute.value = sym(5);

                QStringRef attributeQualifiedName = symName(1);
                bool normalize = false;
                for (int a = 0; a < dtdAttributes.size(); ++a) {
                    DtdAttribute &dtdAttribute = dtdAttributes[a];
                    if (!dtdAttribute.isCDATA
                        && dtdAttribute.tagName == qualifiedName
                        && dtdAttribute.attributeQualifiedName == attributeQualifiedName
                        ) {
                        normalize = true;
                        break;
                    }
                }
                if (normalize) {
                    // normalize attribute value (simplify and trim)
                    int pos = textBuffer.size();
                    int n = 0;
                    bool wasSpace = true;
                    for (int i = 0; i < attribute.value.len; ++i) {
                        QChar c = textBuffer.at(attribute.value.pos + i);
                        if (c.unicode() == ' ') {
                            if (wasSpace)
                                continue;
                            wasSpace = true;
                        } else {
                            wasSpace = false;
                        }
                        textBuffer += textBuffer.at(attribute.value.pos + i);
                        ++n;
                    }
                    if (wasSpace)
                        while (n && textBuffer.at(pos + n - 1).unicode() == ' ')
                            --n;
                    attribute.value.pos = pos;
                    attribute.value.len = n;
                }
                if (prefix == QLatin1String("xmlns") && namespaceProcessing) {
                    NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();
                    QStringRef namespacePrefix = symString(attribute.key);
                    QStringRef namespaceUri = symString(attribute.value);
                    attributeStack.pop();
                    if (((namespacePrefix == QLatin1String("xml"))
                         ^ (namespaceUri == QLatin1String("http://www.w3.org/XML/1998/namespace")))
                        || namespaceUri == QLatin1String("http://www.w3.org/2000/xmlns/")
                        || namespaceUri.isEmpty()
                        || namespacePrefix == QLatin1String("xmlns"))
                        raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));

                    namespaceDeclaration.prefix = addToStringStorage(namespacePrefix);
                    namespaceDeclaration.namespaceUri = addToStringStorage(namespaceUri);
                }
            }
        } break;

        case 235: {
            normalizeLiterals = true;
            Tag &tag = tagStack_push();
            prefix = tag.namespaceDeclaration.prefix  = addToStringStorage(symPrefix(2));
            name = tag.name = addToStringStorage(symString(2));
            qualifiedName = tag.qualifiedName = addToStringStorage(symName(2));
            if ((!prefix.isEmpty() && !QXmlUtils::isNCName(prefix)) || !QXmlUtils::isNCName(name))
                raiseWellFormedError(QXmlStream::tr("Invalid XML name."));
        } break;

        case 236:
            isEmptyElement = true;
        // fall through

        case 237:
            setType(QXmlStreamReader::StartElement);
            resolveTag();
            if (tagStack.size() == 1 && hasSeenTag && !inParseEntity)
                raiseWellFormedError(QXmlStream::tr("Extra content at end of document."));
            hasSeenTag = true;
        break;

        case 238: {
            setType(QXmlStreamReader::EndElement);
            Tag &tag = tagStack_pop();

            namespaceUri = tag.namespaceDeclaration.namespaceUri;
            name = tag.name;
            qualifiedName = tag.qualifiedName;
            if (qualifiedName != symName(3))
                raiseWellFormedError(QXmlStream::tr("Opening and ending tag mismatch."));
        } break;

        case 239:
            if (entitiesMustBeDeclared()) {
                raiseWellFormedError(QXmlStream::tr("Entity '%1' not declared.").arg(unresolvedEntity));
                break;
            }
            setType(QXmlStreamReader::EntityReference);
            name = &unresolvedEntity;
    break;

        case 240: {
            sym(1).len += sym(2).len + 1;
            QString reference = symString(2).toString();
            if (entityHash.contains(reference)) {
                Entity &entity = entityHash[reference];
                if (entity.unparsed) {
                    raiseWellFormedError(QXmlStream::tr("Reference to unparsed entity '%1'.").arg(reference));
                } else {
                    if (!entity.hasBeenParsed) {
                        parseEntity(entity.value);
                        entity.hasBeenParsed = true;
                    }
                    if (entity.literal)
                        putStringLiteral(entity.value);
                    else if (referenceEntity(entity))
                        putReplacement(entity.value);
                    textBuffer.chop(2 + sym(2).len);
                    clearSym();
                }
                break;
            }

            if (entityResolver) {
                QString replacementText = resolveUndeclaredEntity(reference);
                if (!replacementText.isNull()) {
                    putReplacement(replacementText);
                    textBuffer.chop(2 + sym(2).len);
                    clearSym();
                    break;
                }
            }

        injectToken(UNRESOLVED_ENTITY);
        unresolvedEntity = symString(2).toString();
        textBuffer.chop(2 + sym(2).len);
        clearSym();

        } break;

        case 241: {
            sym(1).len += sym(2).len + 1;
            QString reference = symString(2).toString();
            if (parameterEntityHash.contains(reference)) {
                referenceToParameterEntityDetected = true;
                Entity &entity = parameterEntityHash[reference];
                if (entity.unparsed || entity.external) {
                    referenceToUnparsedEntityDetected = true;
                } else {
                    if (referenceEntity(entity))
                        putString(entity.value);
                    textBuffer.chop(2 + sym(2).len);
                    clearSym();
                }
            } else if (entitiesMustBeDeclared()) {
                raiseWellFormedError(QXmlStream::tr("Entity '%1' not declared.").arg(symString(2).toString()));
            }
        } break;

        case 242:
            sym(1).len += sym(2).len + 1;
        break;

        case 243: {
            sym(1).len += sym(2).len + 1;
            QString reference = symString(2).toString();
            if (entityHash.contains(reference)) {
                Entity &entity = entityHash[reference];
                if (entity.unparsed || entity.value.isNull()) {
                    raiseWellFormedError(QXmlStream::tr("Reference to external entity '%1' in attribute value.").arg(reference));
                    break;
                }
                if (!entity.hasBeenParsed) {
                    parseEntity(entity.value);
                    entity.hasBeenParsed = true;
                }
                if (entity.literal)
                    putStringLiteral(entity.value);
                else if (referenceEntity(entity))
                    putReplacementInAttributeValue(entity.value);
                textBuffer.chop(2 + sym(2).len);
                clearSym();
                break;
            }

            if (entityResolver) {
                QString replacementText = resolveUndeclaredEntity(reference);
                if (!replacementText.isNull()) {
                    putReplacement(replacementText);
                    textBuffer.chop(2 + sym(2).len);
                    clearSym();
                    break;
                }
            }
            if (entitiesMustBeDeclared()) {
                raiseWellFormedError(QXmlStream::tr("Entity '%1' not declared.").arg(reference));
            }
        } break;

        case 244: {
            if (uint s = resolveCharRef(3)) {
                if (s >= 0xffff)
                    putStringLiteral(QString::fromUcs4(&s, 1));
                else
                    putChar((LETTER << 16) | s);

                textBuffer.chop(3 + sym(3).len);
                clearSym();
            } else {
                raiseWellFormedError(QXmlStream::tr("Invalid character reference."));
            }
        } break;

        case 247:
        case 248:
            sym(1).len += sym(2).len;
        break;

        case 259:
            sym(1).len += fastScanSpace();
            if (atEnd) {
                resume(259);
                return false;
            }
        break;

        case 262: {
            sym(1).len += fastScanName(&sym(1).prefix);
            if (atEnd) {
                resume(262);
                return false;
            }
        } break;

        case 263:
            sym(1).len += fastScanName();
            if (atEnd) {
                resume(263);
                return false;
            }
        break;

        case 264:
        case 265:
        case 266:
        case 267:
        case 268:
            sym(1).len += fastScanNMTOKEN();
            if (atEnd) {
                resume(268);
                return false;
            }

        break;

    default:
        ;
    } // switch
            act = state_stack[tos] = nt_action (act, lhs[r] - TERMINAL_COUNT);
            if (type != QXmlStreamReader::NoToken)
                return true;
        } else {
            parseError();
            break;
        }
    }
    return false;
}

parseEntity()

void QXmlStreamReaderPrivate::parseEntity

(

const QString &

value

)

Definition at line 895 of file qxmlstream.cpp.

{
    Q_Q(QXmlStreamReader);

    if (value.isEmpty())
        return;


    if (!entityParser)
        entityParser = new QXmlStreamReaderPrivate(q);
    else
        entityParser->init();
    entityParser->inParseEntity = true;
    entityParser->readBuffer = value;
    entityParser->injectToken(PARSE_ENTITY);
    while (!entityParser->atEnd && entityParser->type != QXmlStreamReader::Invalid)
        entityParser->parse();
    if (entityParser->type == QXmlStreamReader::Invalid || entityParser->tagStack.size())
        raiseWellFormedError(QXmlStream::tr("Invalid entity value."));

}

parseError()

void QXmlStreamReaderPrivate::parseError

(

)

Definition at line 1896 of file qxmlstream.cpp.

{

    if (token == EOF_SYMBOL) {
        raiseError(QXmlStreamReader::PrematureEndOfDocumentError);
        return;
    }
    const int nmax = 4;
    QString error_message;
    int ers = state_stack[tos];
    int nexpected = 0;
    int expected[nmax];
    if (token != ERROR)
        for (int tk = 0; tk < TERMINAL_COUNT; ++tk) {
            int k = t_action(ers, tk);
            if (k <= 0)
                continue;
            if (spell[tk]) {
                if (nexpected < nmax)
                    expected[nexpected++] = tk;
            }
        }

    error_message.clear ();
    if (nexpected && nexpected < nmax) {
        bool first = true;

        for (int s = 0; s < nexpected; ++s) {
            if (first)
                error_message += QXmlStream::tr ("Expected ");
            else if (s == nexpected - 1)
                error_message += QLatin1String (nexpected > 2 ? ", or " : " or ");
            else
                error_message += QLatin1String (", ");

            first = false;
            error_message += QLatin1String("\'");
            error_message += QLatin1String (spell [expected[s]]);
            error_message += QLatin1String("\'");
        }
        error_message += QXmlStream::tr(", but got \'");
        error_message += QLatin1String(spell [token]);
        error_message += QLatin1String("\'");
    } else {
        error_message += QXmlStream::tr("Unexpected \'");
        error_message += QLatin1String(spell [token]);
        error_message += QLatin1String("\'");
    }
    error_message += QLatin1Char('.');

    raiseWellFormedError(error_message);
}

peekChar()

uint QXmlStreamReaderPrivate::peekChar ( )

inline

Definition at line 974 of file qxmlstream.cpp.

Referenced by filterCarriageReturn(), scanAfterDefaultDecl(), scanAfterLangleBang(), scanAttType(), and scanPublicOrSystem().

{
    uint c;
    if (putStack.size()) {
        c = putStack.top();
    } else if (readBufferPos < readBuffer.size()) {
        c = readBuffer.at(readBufferPos).unicode();
    } else {
        if ((c = getChar_helper()))
            --readBufferPos;
    }

    return c;
}

putChar() [1/2]

void QXmlStreamReaderPrivate::putChar ( uint  c )

inline

Definition at line 959 of file qxmlstream_p.h.

Referenced by fastScanContentCharList(), fastScanLiteralContent(), fastScanName(), fastScanNMTOKEN(), fastScanSpace(), filterCarriageReturn(), scanNData(), and scanString().

{ putStack.push() = c; }

putChar() [2/2]

void QXmlStreamReaderPrivate::putChar ( QChar  c )

inline

Definition at line 960 of file qxmlstream_p.h.

{ putStack.push() =  c.unicode(); }

putReplacement()

void QXmlStreamReaderPrivate::putReplacement

(

const QString &

s

)

Definition at line 1478 of file qxmlstream.cpp.

{
    putStack.reserve(s.size());
    for (int i = s.size()-1; i >= 0; --i) {
        ushort c = s.at(i).unicode();
        if (c == '\n' || c == '\r')
            putStack.rawPush() = ((LETTER << 16) | c);
        else
            putStack.rawPush() = c;
    }
}

putReplacementInAttributeValue()

void QXmlStreamReaderPrivate::putReplacementInAttributeValue

(

const QString &

s

)

Definition at line 1489 of file qxmlstream.cpp.

{
    putStack.reserve(s.size());
    for (int i = s.size()-1; i >= 0; --i) {
        ushort c = s.at(i).unicode();
        if (c == '&' || c == ';')
            putStack.rawPush() = c;
        else if (c == '\n' || c == '\r')
            putStack.rawPush() = ' ';
        else
            putStack.rawPush() = ((LETTER << 16) | c);
    }
}

putString()

void QXmlStreamReaderPrivate::putString	(	const QString &	s,
		int	from = 0
	)

Definition at line 1464 of file qxmlstream.cpp.

Referenced by fastScanContentCharList(), fastScanName(), fastScanNMTOKEN(), scanString(), and scanUntil().

{
    putStack.reserve(s.size());
    for (int i = s.size()-1; i >= from; --i)
        putStack.rawPush() = s.at(i).unicode();
}

putStringLiteral()

void QXmlStreamReaderPrivate::putStringLiteral

(

const QString &

s

)

Definition at line 1471 of file qxmlstream.cpp.

{
    putStack.reserve(s.size());
    for (int i = s.size()-1; i >= 0; --i)
        putStack.rawPush() = ((LETTER << 16) | s.at(i).unicode());
}

raiseError()

void QXmlStreamReaderPrivate::raiseError	(	QXmlStreamReader::Error	error,
		const QString &	message = QString()
	)

Definition at line 1877 of file qxmlstream.cpp.

Referenced by checkStartDocument(), parseError(), raiseWellFormedError(), and resume().

{
    this->error = error;
    errorString = message;
    if (errorString.isNull()) {
        if (error == QXmlStreamReader::PrematureEndOfDocumentError)
            errorString = QXmlStream::tr("Premature end of document.");
        else if (error == QXmlStreamReader::CustomError)
            errorString = QXmlStream::tr("Invalid document.");
    }

    type = QXmlStreamReader::Invalid;
}

raiseWellFormedError()

void QXmlStreamReaderPrivate::raiseWellFormedError

(

const QString &

message

)

Definition at line 1891 of file qxmlstream.cpp.

Referenced by checkPublicLiteral(), fastScanContentCharList(), getChar_helper(), namespaceForPrefix(), parseEntity(), parseError(), resolveTag(), scanUntil(), and startDocument().

{
    raiseError(QXmlStreamReader::NotWellFormedError, message);
}

reallocateStack()

void QXmlStreamReaderPrivate::reallocateStack ( )

inline

Definition at line 917 of file qxmlstream.cpp.

Referenced by QXmlStreamReaderPrivate().

{
    stack_size <<= 1;
    sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));
    Q_CHECK_PTR(sym_stack);
    state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));
    Q_CHECK_PTR(sym_stack);
}

referenceEntity()

bool QXmlStreamReaderPrivate::referenceEntity ( Entity &  entity )

inline

Definition at line 773 of file qxmlstream_p.h.

                                                {
        if (entity.isCurrentlyReferenced) {
            raiseWellFormedError(QXmlStream::tr("Recursive entity detected."));
            return false;
        }
        entity.isCurrentlyReferenced = true;
        entityReferenceStack.push() = &entity;
        injectToken(ENTITY_DONE);
        return true;
    }

resolveCharRef()

uint QXmlStreamReaderPrivate::resolveCharRef

(

int

symbolIndex

)

Definition at line 1748 of file qxmlstream.cpp.

{
    bool ok = true;
    uint s;
    // ### add toXShort to QStringRef?
    if (sym(symbolIndex).c == 'x')
        s = symString(symbolIndex, 1).toString().toUInt(&ok, 16);
    else
        s = symString(symbolIndex).toString().toUInt(&ok, 10);

    ok &= (s == 0x9 || s == 0xa || s == 0xd || (s >= 0x20 && s <= 0xd7ff)
           || (s >= 0xe000 && s <= 0xfffd) || (s >= 0x10000 && s <= 0x10ffff));

    return ok ? s : 0;
}

resolveDtd()

void QXmlStreamReaderPrivate::resolveDtd

(

)

Definition at line 1722 of file qxmlstream.cpp.

{
    publicNotationDeclarations.resize(notationDeclarations.size());
    for (int i = 0; i < notationDeclarations.size(); ++i) {
        const QXmlStreamReaderPrivate::NotationDeclaration &notationDeclaration = notationDeclarations.at(i);
        QXmlStreamNotationDeclaration &publicNotationDeclaration = publicNotationDeclarations[i];
        publicNotationDeclaration.m_name = QXmlStreamStringRef(notationDeclaration.name);
        publicNotationDeclaration.m_systemId = QXmlStreamStringRef(notationDeclaration.systemId);
        publicNotationDeclaration.m_publicId = QXmlStreamStringRef(notationDeclaration.publicId);

    }
    notationDeclarations.clear();
    publicEntityDeclarations.resize(entityDeclarations.size());
    for (int i = 0; i < entityDeclarations.size(); ++i) {
        const QXmlStreamReaderPrivate::EntityDeclaration &entityDeclaration = entityDeclarations.at(i);
        QXmlStreamEntityDeclaration &publicEntityDeclaration = publicEntityDeclarations[i];
        publicEntityDeclaration.m_name = QXmlStreamStringRef(entityDeclaration.name);
        publicEntityDeclaration.m_notationName = QXmlStreamStringRef(entityDeclaration.notationName);
        publicEntityDeclaration.m_systemId = QXmlStreamStringRef(entityDeclaration.systemId);
        publicEntityDeclaration.m_publicId = QXmlStreamStringRef(entityDeclaration.publicId);
        publicEntityDeclaration.m_value = QXmlStreamStringRef(entityDeclaration.value);
    }
    entityDeclarations.clear();
    parameterEntityHash.clear();
}

resolvePublicNamespaces()

void QXmlStreamReaderPrivate::resolvePublicNamespaces

(

)

Definition at line 1709 of file qxmlstream.cpp.

{
    const Tag &tag = tagStack.top();
    int n = namespaceDeclarations.size() - tag.namespaceDeclarationsSize;
    publicNamespaceDeclarations.resize(n);
    for (int i = 0; i < n; ++i) {
        const NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.at(tag.namespaceDeclarationsSize + i);
        QXmlStreamNamespaceDeclaration &publicNamespaceDeclaration = publicNamespaceDeclarations[i];
        publicNamespaceDeclaration.m_prefix = QXmlStreamStringRef(namespaceDeclaration.prefix);
        publicNamespaceDeclaration.m_namespaceUri = QXmlStreamStringRef(namespaceDeclaration.namespaceUri);
    }
}

resolveTag()

void QXmlStreamReaderPrivate::resolveTag

(

)

Definition at line 1605 of file qxmlstream.cpp.

{
    int n = attributeStack.size();

    if (namespaceProcessing) {
        for (int a = 0; a < dtdAttributes.size(); ++a) {
            DtdAttribute &dtdAttribute = dtdAttributes[a];
            if (!dtdAttribute.isNamespaceAttribute
                || dtdAttribute.defaultValue.isNull()
                || dtdAttribute.tagName != qualifiedName
                || dtdAttribute.attributeQualifiedName.isNull())
                continue;
            int i = 0;
            while (i < n && symName(attributeStack[i].key) != dtdAttribute.attributeQualifiedName)
                ++i;
            if (i != n)
                continue;
            if (dtdAttribute.attributePrefix.isEmpty() && dtdAttribute.attributeName == QLatin1String("xmlns")) {
                NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();
                namespaceDeclaration.prefix.clear();

                const QStringRef ns(dtdAttribute.defaultValue);
                if(ns == QLatin1String("http://www.w3.org/2000/xmlns/") ||
                   ns == QLatin1String("http://www.w3.org/XML/1998/namespace"))
                    raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));
                else
                    namespaceDeclaration.namespaceUri = ns;
            } else if (dtdAttribute.attributePrefix == QLatin1String("xmlns")) {
                NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();
                QStringRef namespacePrefix = dtdAttribute.attributeName;
                QStringRef namespaceUri = dtdAttribute.defaultValue;
                if (((namespacePrefix == QLatin1String("xml"))
                     ^ (namespaceUri == QLatin1String("http://www.w3.org/XML/1998/namespace")))
                    || namespaceUri == QLatin1String("http://www.w3.org/2000/xmlns/")
                    || namespaceUri.isEmpty()
                    || namespacePrefix == QLatin1String("xmlns"))
                    raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));

                namespaceDeclaration.prefix = namespacePrefix;
                namespaceDeclaration.namespaceUri = namespaceUri;
            }
        }
    }

    tagStack.top().namespaceDeclaration.namespaceUri = namespaceUri = namespaceForPrefix(prefix);

    attributes.resize(n);

    for (int i = 0; i < n; ++i) {
        QXmlStreamAttribute &attribute = attributes[i];
        Attribute &attrib = attributeStack[i];
        QStringRef prefix(symPrefix(attrib.key));
        QStringRef name(symString(attrib.key));
        QStringRef qualifiedName(symName(attrib.key));
        QStringRef value(symString(attrib.value));

        attribute.m_name = QXmlStreamStringRef(name);
        attribute.m_qualifiedName = QXmlStreamStringRef(qualifiedName);
        attribute.m_value = QXmlStreamStringRef(value);

        if (!prefix.isEmpty()) {
            QStringRef attributeNamespaceUri = namespaceForPrefix(prefix);
            attribute.m_namespaceUri = QXmlStreamStringRef(attributeNamespaceUri);
        }

        for (int j = 0; j < i; ++j) {
            if (attributes[j].name() == attribute.name()
                && attributes[j].namespaceUri() == attribute.namespaceUri()
                && (namespaceProcessing || attributes[j].qualifiedName() == attribute.qualifiedName()))
                raiseWellFormedError(QXmlStream::tr("Attribute redefined."));
        }
    }

    for (int a = 0; a < dtdAttributes.size(); ++a) {
        DtdAttribute &dtdAttribute = dtdAttributes[a];
        if (dtdAttribute.isNamespaceAttribute
            || dtdAttribute.defaultValue.isNull()
            || dtdAttribute.tagName != qualifiedName
            || dtdAttribute.attributeQualifiedName.isNull())
            continue;
        int i = 0;
        while (i < n && symName(attributeStack[i].key) != dtdAttribute.attributeQualifiedName)
            ++i;
        if (i != n)
            continue;



        QXmlStreamAttribute attribute;
        attribute.m_name = QXmlStreamStringRef(dtdAttribute.attributeName);
        attribute.m_qualifiedName = QXmlStreamStringRef(dtdAttribute.attributeQualifiedName);
        attribute.m_value = QXmlStreamStringRef(dtdAttribute.defaultValue);

        if (!dtdAttribute.attributePrefix.isEmpty()) {
            QStringRef attributeNamespaceUri = namespaceForPrefix(dtdAttribute.attributePrefix);
            attribute.m_namespaceUri = QXmlStreamStringRef(attributeNamespaceUri);
        }
        attribute.m_isDefault = true;
        attributes.append(attribute);
    }

    attributeStack.clear();
}

resolveUndeclaredEntity()

QString QXmlStreamReaderPrivate::resolveUndeclaredEntity

(

const QString &

name

)

Definition at line 224 of file qxmlstream.cpp.

{
    if (entityResolver)
        return entityResolver->resolveUndeclaredEntity(name);
    return QString();
}

resume()

void QXmlStreamReaderPrivate::resume

(

int

rule

)

Definition at line 1949 of file qxmlstream.cpp.

                                             {
    resumeReduction = rule;
    if (error == QXmlStreamReader::NoError)
        raiseError(QXmlStreamReader::PrematureEndOfDocumentError);
}

scanAfterDefaultDecl()

bool QXmlStreamReaderPrivate::scanAfterDefaultDecl

(

)

Definition at line 1127 of file qxmlstream.cpp.

{
    switch (peekChar()) {
    case 'R':
        return scanString(spell[REQUIRED], REQUIRED, false);
    case 'I':
        return scanString(spell[IMPLIED], IMPLIED, false);
    case 'F':
        return scanString(spell[FIXED], FIXED, false);
    default:
        ;
    }
    return false;
}

scanAfterLangleBang()

bool QXmlStreamReaderPrivate::scanAfterLangleBang

(

)

Definition at line 1082 of file qxmlstream.cpp.

{
    switch (peekChar()) {
    case '[':
        return scanString(spell[CDATA_START], CDATA_START, false);
    case 'D':
        return scanString(spell[DOCTYPE], DOCTYPE);
    case 'A':
        return scanString(spell[ATTLIST], ATTLIST);
    case 'N':
        return scanString(spell[NOTATION], NOTATION);
    case 'E':
        if (scanString(spell[ELEMENT], ELEMENT))
            return true;
        return scanString(spell[ENTITY], ENTITY);

    default:
        ;
    };
    return false;
}

scanAttType()

bool QXmlStreamReaderPrivate::scanAttType

(

)

Definition at line 1142 of file qxmlstream.cpp.

{
    switch (peekChar()) {
    case 'C':
        return scanString(spell[CDATA], CDATA);
    case 'I':
        if (scanString(spell[ID], ID))
            return true;
        if (scanString(spell[IDREF], IDREF))
            return true;
        return scanString(spell[IDREFS], IDREFS);
    case 'E':
        if (scanString(spell[ENTITY], ENTITY))
            return true;
        return scanString(spell[ENTITIES], ENTITIES);
    case 'N':
        if (scanString(spell[NOTATION], NOTATION))
            return true;
        if (scanString(spell[NMTOKEN], NMTOKEN))
            return true;
        return scanString(spell[NMTOKENS], NMTOKENS);
    default:
        ;
    }
    return false;
}

scanNData()

bool QXmlStreamReaderPrivate::scanNData

(

)

Definition at line 1117 of file qxmlstream.cpp.

{
    if (fastScanSpace()) {
        if (scanString(spell[NDATA], NDATA))
            return true;
        putChar(' ');
    }
    return false;
}

scanPublicOrSystem()

bool QXmlStreamReaderPrivate::scanPublicOrSystem

(

)

Definition at line 1104 of file qxmlstream.cpp.

{
    switch (peekChar()) {
    case 'S':
        return scanString(spell[SYSTEM], SYSTEM);
    case 'P':
        return scanString(spell[PUBLIC], PUBLIC);
    default:
        ;
    }
    return false;
}

scanString()

bool QXmlStreamReaderPrivate::scanString	(	const char *	str,
		short	tokenToInject,
		bool	requireSpace = true
	)

Definition at line 1051 of file qxmlstream.cpp.

Referenced by checkStartDocument(), scanAfterDefaultDecl(), scanAfterLangleBang(), scanAttType(), scanNData(), scanPublicOrSystem(), and scanUntil().

{
    int n = 0;
    while (str[n]) {
        ushort c = getChar();
        if (c != ushort(str[n])) {
            if (c)
                putChar(c);
            while (n--) {
                putChar(ushort(str[n]));
            }
            return false;
        }
        ++n;
    }
    for (int i = 0; i < n; ++i)
        textBuffer += QChar(ushort(str[i]));
    if (requireSpace) {
        int s = fastScanSpace();
        if (!s || atEnd) {
            int pos = textBuffer.size() - n - s;
            putString(textBuffer, pos);
            textBuffer.resize(pos);
            return false;
        }
    }
    if (tokenToInject >= 0)
        injectToken(tokenToInject);
    return true;
}

scanUntil()

bool QXmlStreamReaderPrivate::scanUntil	(	const char *	str,
		short	tokenToInject = -1
	)

Scans characters until str is encountered, and validates the characters as according to the Char[2] production and do the line-ending normalization.

Warning

This function is not part of the public interface.

If any character is invalid, false is returned, otherwise true upon success.

If tokenToInject is not less than zero, injectToken() is called with tokenToInject when str is found.

If any error occurred, false is returned, otherwise true.

Definition at line 1004 of file qxmlstream.cpp.

{
    int pos = textBuffer.size();
    int oldLineNumber = lineNumber;

    while (uint c = getChar()) {
        /* First, we do the validation & normalization. */
        switch (c) {
        case '\r':
            if ((c = filterCarriageReturn()) == 0)
                break;
            // fall through
        case '\n':
            ++lineNumber;
            lastLineStart = characterOffset + readBufferPos;
            // fall through
        case '\t':
            textBuffer += QChar(c);
            continue;
        default:
            if(c < 0x20 || (c > 0xFFFD && c < 0x10000) || c > 0x10FFFF ) {
                raiseWellFormedError(QXmlStream::tr("Invalid XML character."));
                lineNumber = oldLineNumber;
                return false;
            }
            textBuffer += QChar(c);
        }


        /* Second, attempt to lookup str. */
        if (c == uint(*str)) {
            if (!*(str + 1)) {
                if (tokenToInject >= 0)
                    injectToken(tokenToInject);
                return true;
            } else {
                if (scanString(str + 1, tokenToInject, false))
                    return true;
            }
        }
    }
    putString(textBuffer, pos);
    textBuffer.resize(pos);
    lineNumber = oldLineNumber;
    return false;
}

setType()

void QXmlStreamReaderPrivate::setType ( const QXmlStreamReader::TokenType  t )

inlineprivate

Never assign to variable type directly.

Warning

This function is not part of the public interface. Instead use this function.

  This prevents errors from being ignored.

Definition at line 1010 of file qxmlstream_p.h.

    {
        if(type != QXmlStreamReader::Invalid)
            type = t;
    }

startDocument()

void QXmlStreamReaderPrivate::startDocument

(

)

Definition at line 1812 of file qxmlstream.cpp.

{
    QString err;
    if (documentVersion != QLatin1String("1.0")) {
        if (documentVersion.toString().contains(QLatin1Char(' ')))
            err = QXmlStream::tr("Invalid XML version string.");
        else
            err = QXmlStream::tr("Unsupported XML version.");
    }
    int n = attributeStack.size();

    /* We use this bool to ensure that the pesudo attributes are in the
     * proper order:
     *
     * [23]     XMLDecl     ::=     '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>' */
    bool hasStandalone = false;

    for (int i = 0; err.isNull() && i < n; ++i) {
        Attribute &attrib = attributeStack[i];
        QStringRef prefix(symPrefix(attrib.key));
        QStringRef key(symString(attrib.key));
        QStringRef value(symString(attrib.value));

        if (prefix.isEmpty() && key == QLatin1String("encoding")) {
            const QString name(value.toString());
            documentEncoding = value;

            if(hasStandalone)
                err = QXmlStream::tr("The standalone pseudo attribute must appear after the encoding.");
            if(!QXmlUtils::isEncName(name))
                err = QXmlStream::tr("%1 is an invalid encoding name.").arg(name);
            else {
#ifdef QT_NO_TEXTCODEC
                readBuffer = QString::fromLatin1(rawReadBuffer.data(), nbytesread);
#else
                QTextCodec *const newCodec = QTextCodec::codecForName(name.toLatin1());
                if (!newCodec)
                    err = QXmlStream::tr("Encoding %1 is unsupported").arg(name);
                else if (newCodec != codec && !lockEncoding) {
                    codec = newCodec;
                    delete decoder;
                    decoder = codec->makeDecoder();
                    decoder->toUnicode(&readBuffer, rawReadBuffer.data(), nbytesread);
                }
#endif // QT_NO_TEXTCODEC
            }
        } else if (prefix.isEmpty() && key == QLatin1String("standalone")) {
            hasStandalone = true;
            if (value == QLatin1String("yes"))
                standalone = true;
            else if (value == QLatin1String("no"))
                standalone = false;
            else
                err = QXmlStream::tr("Standalone accepts only yes or no.");
        } else {
            err = QXmlStream::tr("Invalid attribute in XML declaration.");
        }
    }

    if (!err.isNull())
        raiseWellFormedError(err);
    attributeStack.clear();
}

sym()

Value& QXmlStreamReaderPrivate::sym ( int  index ) const

inline

Definition at line 905 of file qxmlstream_p.h.

Referenced by resolveCharRef().

    { return sym_stack[tos + index - 1]; }

symName() [1/2]

QStringRef QXmlStreamReaderPrivate::symName ( int  index )

inline

Definition at line 924 of file qxmlstream_p.h.

Referenced by resolveTag().

                                         {
        const Value &symbol = sym(index);
        return QStringRef(&textBuffer, symbol.pos, symbol.len);
    }

symName() [2/2]

QStringRef QXmlStreamReaderPrivate::symName ( const Value &  symbol )

inline

Definition at line 941 of file qxmlstream_p.h.

                                                   {
        return QStringRef(&textBuffer, symbol.pos, symbol.len);
    }

symPrefix() [1/2]

QStringRef QXmlStreamReaderPrivate::symPrefix ( int  index )

inline

Definition at line 932 of file qxmlstream_p.h.

Referenced by resolveTag(), and startDocument().

                                           {
        const Value &symbol = sym(index);
        if (symbol.prefix)
            return QStringRef(&textBuffer, symbol.pos, symbol.prefix - 1);
        return QStringRef();
    }

symPrefix() [2/2]

QStringRef QXmlStreamReaderPrivate::symPrefix ( const Value &  symbol )

inline

Definition at line 944 of file qxmlstream_p.h.

                                                     {
        if (symbol.prefix)
            return QStringRef(&textBuffer, symbol.pos, symbol.prefix - 1);
        return QStringRef();
    }

symString() [1/3]

QStringRef QXmlStreamReaderPrivate::symString ( int  index )

inline

Definition at line 920 of file qxmlstream_p.h.

Referenced by resolveCharRef(), resolveTag(), and startDocument().

                                           {
        const Value &symbol = sym(index);
        return QStringRef(&textBuffer, symbol.pos + symbol.prefix, symbol.len - symbol.prefix);
    }

symString() [2/3]

QStringRef QXmlStreamReaderPrivate::symString ( int  index, int  offset  )

inline

Definition at line 928 of file qxmlstream_p.h.

                                                       {
        const Value &symbol = sym(index);
        return QStringRef(&textBuffer, symbol.pos + symbol.prefix + offset, symbol.len - symbol.prefix -  offset);
    }

symString() [3/3]

QStringRef QXmlStreamReaderPrivate::symString ( const Value &  symbol )

inline

Definition at line 938 of file qxmlstream_p.h.

                                                     {
        return QStringRef(&textBuffer, symbol.pos + symbol.prefix, symbol.len - symbol.prefix);
    }

write() [1/2]

void QXmlStreamReaderPrivate::write

(

const QString &

)

Referenced by QXmlStreamWriterPrivate::~QXmlStreamWriterPrivate().

write() [2/2]

void QXmlStreamReaderPrivate::write

(

const char *

)

Properties

atEnd

bool QXmlStreamReaderPrivate::atEnd

Definition at line 791 of file qxmlstream_p.h.

Referenced by checkStartDocument(), getChar(), getChar_helper(), init(), parseEntity(), and scanString().

attributes

QXmlStreamAttributes QXmlStreamReaderPrivate::attributes

Definition at line 808 of file qxmlstream_p.h.

Referenced by init(), and resolveTag().

attributeStack

QXmlStreamSimpleStack<Attribute> QXmlStreamReaderPrivate::attributeStack

Definition at line 918 of file qxmlstream_p.h.

Referenced by init(), resolveTag(), and startDocument().

characterOffset

qint64 QXmlStreamReaderPrivate::characterOffset

Definition at line 801 of file qxmlstream_p.h.

Referenced by fastScanContentCharList(), fastScanLiteralContent(), fastScanSpace(), getChar_helper(), init(), and scanUntil().

codec

QTextCodec* QXmlStreamReaderPrivate::codec

Definition at line 788 of file qxmlstream_p.h.

Referenced by getChar_helper(), init(), and startDocument().

dataBuffer

QByteArray QXmlStreamReaderPrivate::dataBuffer

Definition at line 751 of file qxmlstream_p.h.

Referenced by getChar_helper(), and init().

decoder

QTextDecoder* QXmlStreamReaderPrivate::decoder

Definition at line 789 of file qxmlstream_p.h.

Referenced by getChar_helper(), init(), QXmlStreamReaderPrivate(), startDocument(), and ~QXmlStreamReaderPrivate().

deleteDevice

bool QXmlStreamReaderPrivate::deleteDevice

Definition at line 786 of file qxmlstream_p.h.

Referenced by QXmlStreamReaderPrivate(), and QXmlStreamWriterPrivate::~QXmlStreamWriterPrivate().

device

QIODevice* QXmlStreamReaderPrivate::device

Definition at line 785 of file qxmlstream_p.h.

Referenced by getChar_helper(), QXmlStreamReaderPrivate(), and QXmlStreamWriterPrivate::~QXmlStreamWriterPrivate().

documentEncoding

QStringRef QXmlStreamReaderPrivate::documentEncoding

Definition at line 866 of file qxmlstream_p.h.

Referenced by startDocument().

documentVersion

QStringRef QXmlStreamReaderPrivate::documentVersion

Definition at line 866 of file qxmlstream_p.h.

Referenced by startDocument().

dtdAttributes

QXmlStreamSimpleStack<DtdAttribute> QXmlStreamReaderPrivate::dtdAttributes

Definition at line 831 of file qxmlstream_p.h.

Referenced by resolveTag().

dtdName

QStringRef QXmlStreamReaderPrivate::dtdName

Definition at line 865 of file qxmlstream_p.h.

dtdPublicId

QStringRef QXmlStreamReaderPrivate::dtdPublicId

Definition at line 865 of file qxmlstream_p.h.

dtdSystemId

QStringRef QXmlStreamReaderPrivate::dtdSystemId

Definition at line 865 of file qxmlstream_p.h.

entityDeclarations

QXmlStreamSimpleStack<EntityDeclaration> QXmlStreamReaderPrivate::entityDeclarations

Definition at line 858 of file qxmlstream_p.h.

Referenced by resolveDtd().

entityHash

QHash<QString, Entity> QXmlStreamReaderPrivate::entityHash

Definition at line 770 of file qxmlstream_p.h.

Referenced by QXmlStreamReaderPrivate().

entityParser

QXmlStreamReaderPrivate* QXmlStreamReaderPrivate::entityParser

Definition at line 975 of file qxmlstream_p.h.

Referenced by init(), parseEntity(), and ~QXmlStreamReaderPrivate().

entityReferenceStack

QXmlStreamSimpleStack<Entity *> QXmlStreamReaderPrivate::entityReferenceStack

Definition at line 772 of file qxmlstream_p.h.

entityResolver

QXmlStreamEntityResolver* QXmlStreamReaderPrivate::entityResolver

Definition at line 999 of file qxmlstream_p.h.

Referenced by QXmlStreamReaderPrivate().

error

QXmlStreamReader::Error QXmlStreamReaderPrivate::error

Definition at line 797 of file qxmlstream_p.h.

Referenced by init(), raiseError(), and resume().

errorString

QString QXmlStreamReaderPrivate::errorString

Definition at line 798 of file qxmlstream_p.h.

Referenced by raiseError().

firstByte

uchar QXmlStreamReaderPrivate::firstByte

Definition at line 752 of file qxmlstream_p.h.

hasCheckedStartDocument

uint QXmlStreamReaderPrivate::hasCheckedStartDocument

Definition at line 871 of file qxmlstream_p.h.

Referenced by checkStartDocument(), and init().

hasExternalDtdSubset

uint QXmlStreamReaderPrivate::hasExternalDtdSubset

Definition at line 877 of file qxmlstream_p.h.

Referenced by init().

hasSeenTag

uint QXmlStreamReaderPrivate::hasSeenTag

Definition at line 873 of file qxmlstream_p.h.

Referenced by init().

inParseEntity

uint QXmlStreamReaderPrivate::inParseEntity

Definition at line 874 of file qxmlstream_p.h.

Referenced by init(), and parseEntity().

isCDATA

uint QXmlStreamReaderPrivate::isCDATA

Definition at line 869 of file qxmlstream_p.h.

Referenced by init().

isEmptyElement

uint QXmlStreamReaderPrivate::isEmptyElement

Definition at line 867 of file qxmlstream_p.h.

Referenced by init().

isWhitespace

uint QXmlStreamReaderPrivate::isWhitespace

Definition at line 868 of file qxmlstream_p.h.

Referenced by fastScanContentCharList(), and init().

lastAttributeIsCData

bool QXmlStreamReaderPrivate::lastAttributeIsCData

Definition at line 821 of file qxmlstream_p.h.

lastAttributeValue

QStringRef QXmlStreamReaderPrivate::lastAttributeValue

Definition at line 820 of file qxmlstream_p.h.

lastLineStart

qint64 QXmlStreamReaderPrivate::lastLineStart

Definition at line 801 of file qxmlstream_p.h.

Referenced by fastScanContentCharList(), fastScanLiteralContent(), fastScanSpace(), init(), and scanUntil().

lineNumber

qint64 QXmlStreamReaderPrivate::lineNumber

Definition at line 801 of file qxmlstream_p.h.

Referenced by fastScanContentCharList(), fastScanLiteralContent(), fastScanSpace(), init(), and scanUntil().

lockEncoding

uint QXmlStreamReaderPrivate::lockEncoding

Definition at line 878 of file qxmlstream_p.h.

Referenced by getChar_helper(), init(), and startDocument().

name

QStringRef QXmlStreamReaderPrivate::name

Definition at line 863 of file qxmlstream_p.h.

Referenced by resolveTag(), startDocument(), and QXmlStreamWriterPrivate::write().

namespaceProcessing

uint QXmlStreamReaderPrivate::namespaceProcessing

Definition at line 879 of file qxmlstream_p.h.

Referenced by init(), namespaceForPrefix(), and resolveTag().

namespaceUri

QStringRef QXmlStreamReaderPrivate::namespaceUri

Definition at line 863 of file qxmlstream_p.h.

Referenced by QXmlStreamNamespaceDeclaration::operator==(), QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration(), resolveTag(), QXmlStreamAttributes::value(), and QXmlStreamWriterPrivate::write().

nbytesread

qint64 QXmlStreamReaderPrivate::nbytesread

Definition at line 753 of file qxmlstream_p.h.

Referenced by getChar_helper(), init(), and startDocument().

normalizeLiterals

uint QXmlStreamReaderPrivate::normalizeLiterals

Definition at line 872 of file qxmlstream_p.h.

Referenced by fastScanLiteralContent(), and init().

notationDeclarations

QXmlStreamSimpleStack<NotationDeclaration> QXmlStreamReaderPrivate::notationDeclarations

Definition at line 837 of file qxmlstream_p.h.

Referenced by resolveDtd().

parameterEntityHash

QHash<QString, Entity> QXmlStreamReaderPrivate::parameterEntityHash

Definition at line 771 of file qxmlstream_p.h.

Referenced by resolveDtd().

prefix

QStringRef QXmlStreamReaderPrivate::prefix

Definition at line 863 of file qxmlstream_p.h.

Referenced by QXmlStreamNamespaceDeclaration::operator==(), QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration(), resolveTag(), and startDocument().

processingInstructionData

QStringRef QXmlStreamReaderPrivate::processingInstructionData

Definition at line 864 of file qxmlstream_p.h.

processingInstructionTarget

QStringRef QXmlStreamReaderPrivate::processingInstructionTarget

Definition at line 864 of file qxmlstream_p.h.

publicEntityDeclarations

QXmlStreamEntityDeclarations QXmlStreamReaderPrivate::publicEntityDeclarations

Definition at line 859 of file qxmlstream_p.h.

Referenced by resolveDtd().

publicNamespaceDeclarations

QXmlStreamNamespaceDeclarations QXmlStreamReaderPrivate::publicNamespaceDeclarations

Definition at line 839 of file qxmlstream_p.h.

Referenced by resolvePublicNamespaces().

publicNotationDeclarations

QXmlStreamNotationDeclarations QXmlStreamReaderPrivate::publicNotationDeclarations

Definition at line 838 of file qxmlstream_p.h.

Referenced by resolveDtd().

putStack

QXmlStreamSimpleStack<uint> QXmlStreamReaderPrivate::putStack

Definition at line 756 of file qxmlstream_p.h.

Referenced by filterCarriageReturn(), getChar(), init(), peekChar(), putReplacement(), putReplacementInAttributeValue(), putString(), and putStringLiteral().

q_ptr

QXmlStreamReader* QXmlStreamReaderPrivate::q_ptr

private

Definition at line 743 of file qxmlstream_p.h.

qualifiedName

QStringRef QXmlStreamReaderPrivate::qualifiedName

Definition at line 863 of file qxmlstream_p.h.

Referenced by resolveTag(), and QXmlStreamAttributes::value().

rawReadBuffer

QByteArray QXmlStreamReaderPrivate::rawReadBuffer

Definition at line 750 of file qxmlstream_p.h.

Referenced by getChar_helper(), init(), and startDocument().

readBuffer

QString QXmlStreamReaderPrivate::readBuffer

Definition at line 754 of file qxmlstream_p.h.

Referenced by getChar(), getChar_helper(), init(), parseEntity(), peekChar(), and startDocument().

readBufferPos

int QXmlStreamReaderPrivate::readBufferPos

Definition at line 755 of file qxmlstream_p.h.

Referenced by fastScanContentCharList(), fastScanLiteralContent(), fastScanSpace(), filterCarriageReturn(), getChar(), getChar_helper(), init(), peekChar(), and scanUntil().

referenceToParameterEntityDetected

uint QXmlStreamReaderPrivate::referenceToParameterEntityDetected

Definition at line 876 of file qxmlstream_p.h.

Referenced by init().

referenceToUnparsedEntityDetected

uint QXmlStreamReaderPrivate::referenceToUnparsedEntityDetected

Definition at line 875 of file qxmlstream_p.h.

Referenced by init().

resumeReduction

int QXmlStreamReaderPrivate::resumeReduction

Definition at line 881 of file qxmlstream_p.h.

Referenced by init(), and resume().

scanDtd

bool QXmlStreamReaderPrivate::scanDtd

Definition at line 819 of file qxmlstream_p.h.

Referenced by init().

stack_size

int QXmlStreamReaderPrivate::stack_size

Definition at line 894 of file qxmlstream_p.h.

Referenced by QXmlStreamReaderPrivate(), and reallocateStack().

standalone

uint QXmlStreamReaderPrivate::standalone

Definition at line 870 of file qxmlstream_p.h.

Referenced by init(), and startDocument().

state_stack

int* QXmlStreamReaderPrivate::state_stack

Definition at line 903 of file qxmlstream_p.h.

Referenced by init(), parseError(), QXmlStreamReaderPrivate(), reallocateStack(), and ~QXmlStreamReaderPrivate().

sym_stack

Value* QXmlStreamReaderPrivate::sym_stack

Definition at line 902 of file qxmlstream_p.h.

Referenced by QXmlStreamReaderPrivate(), reallocateStack(), and ~QXmlStreamReaderPrivate().

text

QStringRef QXmlStreamReaderPrivate::text

Definition at line 861 of file qxmlstream_p.h.

textBuffer

QString QXmlStreamReaderPrivate::textBuffer

Definition at line 907 of file qxmlstream_p.h.

Referenced by fastScanContentCharList(), fastScanLiteralContent(), fastScanName(), fastScanNMTOKEN(), fastScanSpace(), init(), scanString(), and scanUntil().

token

short QXmlStreamReaderPrivate::token

Definition at line 953 of file qxmlstream_p.h.

Referenced by init(), and parseError().

token_char

ushort QXmlStreamReaderPrivate::token_char

Definition at line 954 of file qxmlstream_p.h.

Referenced by init().

tos

int QXmlStreamReaderPrivate::tos

Definition at line 893 of file qxmlstream_p.h.

Referenced by init(), and parseError().

type

QXmlStreamReader::TokenType QXmlStreamReaderPrivate::type

See also

setType()

Definition at line 796 of file qxmlstream_p.h.

Referenced by checkStartDocument(), init(), parseEntity(), and raiseError().

unresolvedEntity

QString QXmlStreamReaderPrivate::unresolvedEntity

Definition at line 799 of file qxmlstream_p.h.

---

The documentation for this class was generated from the following files:

• /src/corelib/xml/qxmlstream_p.h
• /src/corelib/xml/qxmlstream.cpp