/**************************************************************************** ** ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). ** All rights reserved. ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the QtCore module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** Commercial Usage ** Licensees holding valid Qt Commercial licenses may use this file in ** accordance with the Qt Commercial License Agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and Nokia. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 2.1 requirements ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Nokia gives you certain additional ** rights. These rights are described in the Nokia Qt LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 3.0 as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU General Public License version 3.0 requirements will be ** met: http://www.gnu.org/copyleft/gpl.html. ** ** If you have questions regarding the use of this file, please contact ** Nokia at qt-info@nokia.com. ** $QT_END_LICENSE$ ** ****************************************************************************/ // // W A R N I N G // ------------- // // This file is not part of the Qt API. It exists for the convenience // of other Qt classes. This header file may change from version to // version without notice, or even be removed. // // We mean it. // // This file was generated by qlalr - DO NOT EDIT! #ifndef QXMLSTREAM_P_H #define QXMLSTREAM_P_H #if defined(ERROR) # undef ERROR #endif class QXmlStreamReader_Table { public: 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 const char *const spell []; static const short lhs []; static const short rhs []; static const short goto_default []; static const short action_default []; static const short action_index []; static const short action_info []; static const short action_check []; static inline int nt_action (int state, int nt) { const int yyn = action_index [GOTO_INDEX_OFFSET + state] + nt; if (yyn < 0 || action_check [GOTO_CHECK_OFFSET + yyn] != nt) return goto_default [nt]; return action_info [GOTO_INFO_OFFSET + yyn]; } static inline int t_action (int state, int token) { const int yyn = action_index [state] + token; if (yyn < 0 || action_check [yyn] != token) return - action_default [state]; return action_info [yyn]; } }; const char *const QXmlStreamReader_Table::spell [] = { "end of file", 0, " ", "<", ">", "&", "#", "\'", "\"", "[", "]", "(", ")", "|", "=", "%", "/", ":", ";", ",", "-", "+", "*", ".", "?", "!", "[a-zA-Z]", "[0-9]", "[CDATA[", "DOCTYPE", "ELEMENT", "ATTLIST", "ENTITY", "NOTATION", "SYSTEM", "PUBLIC", "NDATA", "REQUIRED", "IMPLIED", "FIXED", "EMPTY", "ANY", "PCDATA", 0, 0, 0, 0, "CDATA", "ID", "IDREF", "IDREFS", "ENTITIES", "NMTOKEN", "NMTOKENS", " class QXmlStreamSimpleStack { T *data; int tos, cap; public: inline QXmlStreamSimpleStack():data(0), tos(-1), cap(0){} inline ~QXmlStreamSimpleStack(){ if (data) qFree(data); } inline void reserve(int extraCapacity) { if (tos + extraCapacity + 1 > cap) { cap = qMax(tos + extraCapacity + 1, cap << 1 ); data = reinterpret_cast(qRealloc(data, cap * sizeof(T))); Q_CHECK_PTR(data); } } inline T &push() { reserve(1); return data[++tos]; } inline T &rawPush() { return data[++tos]; } inline const T &top() const { return data[tos]; } inline T &top() { return data[tos]; } inline T &pop() { return data[tos--]; } inline T &operator[](int index) { return data[index]; } inline const T &at(int index) const { return data[index]; } inline int size() const { return tos + 1; } inline void resize(int s) { tos = s - 1; } inline bool isEmpty() const { return tos < 0; } inline void clear() { tos = -1; } }; class QXmlStream { Q_DECLARE_TR_FUNCTIONS(QXmlStream) }; class QXmlStreamPrivateTagStack { public: struct NamespaceDeclaration { QStringRef prefix; QStringRef namespaceUri; }; struct Tag { QStringRef name; QStringRef qualifiedName; NamespaceDeclaration namespaceDeclaration; int tagStackStringStorageSize; int namespaceDeclarationsSize; }; QXmlStreamPrivateTagStack(); QXmlStreamSimpleStack namespaceDeclarations; QString tagStackStringStorage; int tagStackStringStorageSize; bool tagsDone; inline QStringRef addToStringStorage(const QStringRef &s) { int pos = tagStackStringStorageSize; int sz = s.size(); if (pos != tagStackStringStorage.size()) tagStackStringStorage.resize(pos); tagStackStringStorage.insert(pos, s.unicode(), sz); tagStackStringStorageSize += sz; return QStringRef(&tagStackStringStorage, pos, sz); } inline QStringRef addToStringStorage(const QString &s) { int pos = tagStackStringStorageSize; int sz = s.size(); if (pos != tagStackStringStorage.size()) tagStackStringStorage.resize(pos); tagStackStringStorage.insert(pos, s.unicode(), sz); tagStackStringStorageSize += sz; return QStringRef(&tagStackStringStorage, pos, sz); } QXmlStreamSimpleStack tagStack; inline Tag &tagStack_pop() { Tag& tag = tagStack.pop(); tagStackStringStorageSize = tag.tagStackStringStorageSize; namespaceDeclarations.resize(tag.namespaceDeclarationsSize); tagsDone = tagStack.isEmpty(); return tag; } inline Tag &tagStack_push() { Tag &tag = tagStack.push(); tag.tagStackStringStorageSize = tagStackStringStorageSize; tag.namespaceDeclarationsSize = namespaceDeclarations.size(); return tag; } }; class QXmlStreamEntityResolver; #ifndef QT_NO_XMLSTREAMREADER class QXmlStreamReaderPrivate : public QXmlStreamReader_Table, public QXmlStreamPrivateTagStack{ QXmlStreamReader *q_ptr; Q_DECLARE_PUBLIC(QXmlStreamReader) public: QXmlStreamReaderPrivate(QXmlStreamReader *q); ~QXmlStreamReaderPrivate(); void init(); QByteArray rawReadBuffer; QByteArray dataBuffer; uchar firstByte; qint64 nbytesread; QString readBuffer; int readBufferPos; QXmlStreamSimpleStack putStack; struct Entity { Entity(const QString& str = QString()) :value(str), external(false), unparsed(false), literal(false), hasBeenParsed(false), isCurrentlyReferenced(false){} static inline Entity createLiteral(const QString &entity) { Entity result(entity); result.literal = result.hasBeenParsed = true; return result; } QString value; uint external : 1; uint unparsed : 1; uint literal : 1; uint hasBeenParsed : 1; uint isCurrentlyReferenced : 1; }; QHash entityHash; QHash parameterEntityHash; QXmlStreamSimpleStackentityReferenceStack; inline bool referenceEntity(Entity &entity) { if (entity.isCurrentlyReferenced) { raiseWellFormedError(QXmlStream::tr("Recursive entity detected.")); return false; } entity.isCurrentlyReferenced = true; entityReferenceStack.push() = &entity; injectToken(ENTITY_DONE); return true; } QIODevice *device; bool deleteDevice; #ifndef QT_NO_TEXTCODEC QTextCodec *codec; QTextDecoder *decoder; #endif bool atEnd; /*! \sa setType() */ QXmlStreamReader::TokenType type; QXmlStreamReader::Error error; QString errorString; QString unresolvedEntity; qint64 lineNumber, lastLineStart, characterOffset; void write(const QString &); void write(const char *); QXmlStreamAttributes attributes; QStringRef namespaceForPrefix(const QStringRef &prefix); void resolveTag(); void resolvePublicNamespaces(); void resolveDtd(); uint resolveCharRef(int symbolIndex); bool checkStartDocument(); void startDocument(); void parseError(); void checkPublicLiteral(const QStringRef &publicId); bool scanDtd; QStringRef lastAttributeValue; bool lastAttributeIsCData; struct DtdAttribute { QStringRef tagName; QStringRef attributeQualifiedName; QStringRef attributePrefix; QStringRef attributeName; QStringRef defaultValue; bool isCDATA; bool isNamespaceAttribute; }; QXmlStreamSimpleStack dtdAttributes; struct NotationDeclaration { QStringRef name; QStringRef publicId; QStringRef systemId; }; QXmlStreamSimpleStack notationDeclarations; QXmlStreamNotationDeclarations publicNotationDeclarations; QXmlStreamNamespaceDeclarations publicNamespaceDeclarations; struct EntityDeclaration { QStringRef name; QStringRef notationName; QStringRef publicId; QStringRef systemId; QStringRef value; bool parameter; bool external; inline void clear() { name.clear(); notationName.clear(); publicId.clear(); systemId.clear(); value.clear(); parameter = external = false; } }; QXmlStreamSimpleStack entityDeclarations; QXmlStreamEntityDeclarations publicEntityDeclarations; QStringRef text; QStringRef prefix, namespaceUri, qualifiedName, name; QStringRef processingInstructionTarget, processingInstructionData; QStringRef dtdName, dtdPublicId, dtdSystemId; QStringRef documentVersion, documentEncoding; uint isEmptyElement : 1; uint isWhitespace : 1; uint isCDATA : 1; uint standalone : 1; uint hasCheckedStartDocument : 1; uint normalizeLiterals : 1; uint hasSeenTag : 1; uint inParseEntity : 1; uint referenceToUnparsedEntityDetected : 1; uint referenceToParameterEntityDetected : 1; uint hasExternalDtdSubset : 1; uint lockEncoding : 1; uint namespaceProcessing : 1; int resumeReduction; void resume(int rule); inline bool entitiesMustBeDeclared() const { return (!inParseEntity && (standalone || (!referenceToUnparsedEntityDetected && !referenceToParameterEntityDetected // Errata 13 as of 2006-04-25 && !hasExternalDtdSubset))); } // qlalr parser int tos; int stack_size; struct Value { int pos; int len; int prefix; ushort c; }; Value *sym_stack; int *state_stack; inline void reallocateStack(); inline Value &sym(int index) const { return sym_stack[tos + index - 1]; } QString textBuffer; inline void clearTextBuffer() { if (!scanDtd) { textBuffer.resize(0); textBuffer.reserve(256); } } struct Attribute { Value key; Value value; }; QXmlStreamSimpleStack attributeStack; inline QStringRef symString(int index) { const Value &symbol = sym(index); return QStringRef(&textBuffer, symbol.pos + symbol.prefix, symbol.len - symbol.prefix); } inline QStringRef symName(int index) { const Value &symbol = sym(index); return QStringRef(&textBuffer, symbol.pos, symbol.len); } inline QStringRef symString(int index, int offset) { const Value &symbol = sym(index); return QStringRef(&textBuffer, symbol.pos + symbol.prefix + offset, symbol.len - symbol.prefix - offset); } inline QStringRef symPrefix(int index) { const Value &symbol = sym(index); if (symbol.prefix) return QStringRef(&textBuffer, symbol.pos, symbol.prefix - 1); return QStringRef(); } inline QStringRef symString(const Value &symbol) { return QStringRef(&textBuffer, symbol.pos + symbol.prefix, symbol.len - symbol.prefix); } inline QStringRef symName(const Value &symbol) { return QStringRef(&textBuffer, symbol.pos, symbol.len); } inline QStringRef symPrefix(const Value &symbol) { if (symbol.prefix) return QStringRef(&textBuffer, symbol.pos, symbol.prefix - 1); return QStringRef(); } inline void clearSym() { Value &val = sym(1); val.pos = textBuffer.size(); val.len = 0; } short token; ushort token_char; uint filterCarriageReturn(); inline uint getChar(); inline uint peekChar(); inline void putChar(uint c) { putStack.push() = c; } inline void putChar(QChar c) { putStack.push() = c.unicode(); } void putString(const QString &s, int from = 0); void putStringLiteral(const QString &s); void putReplacement(const QString &s); void putReplacementInAttributeValue(const QString &s); ushort getChar_helper(); bool scanUntil(const char *str, short tokenToInject = -1); bool scanString(const char *str, short tokenToInject, bool requireSpace = true); inline void injectToken(ushort tokenToInject) { putChar(int(tokenToInject) << 16); } QString resolveUndeclaredEntity(const QString &name); void parseEntity(const QString &value); QXmlStreamReaderPrivate *entityParser; bool scanAfterLangleBang(); bool scanPublicOrSystem(); bool scanNData(); bool scanAfterDefaultDecl(); bool scanAttType(); // scan optimization functions. Not strictly necessary but LALR is // not very well suited for scanning fast int fastScanLiteralContent(); int fastScanSpace(); int fastScanContentCharList(); int fastScanName(int *prefix = 0); inline int fastScanNMTOKEN(); bool parse(); inline void consumeRule(int); void raiseError(QXmlStreamReader::Error error, const QString& message = QString()); void raiseWellFormedError(const QString &message); QXmlStreamEntityResolver *entityResolver; private: /*! \internal Never assign to variable type directly. Instead use this function. This prevents errors from being ignored. */ inline void setType(const QXmlStreamReader::TokenType t) { if(type != QXmlStreamReader::Invalid) type = t; } }; bool QXmlStreamReaderPrivate::parse() { // 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 &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 ¬ationDeclaration = notationDeclarations.push(); notationDeclaration.name = symString(3); } break; case 103: { NotationDeclaration ¬ationDeclaration = notationDeclarations.top(); notationDeclaration.systemId = symString(3); notationDeclaration.publicId.clear(); } break; case 104: { NotationDeclaration ¬ationDeclaration = notationDeclarations.top(); notationDeclaration.systemId.clear(); checkPublicLiteral((notationDeclaration.publicId = symString(3))); } break; case 105: { NotationDeclaration ¬ationDeclaration = 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; } #endif //QT_NO_XMLSTREAMREADER.xml #endif // QXMLSTREAM_P_H