qxmlstream.g - mozsearch

++ -- Copyright (C) 2020 The Qt Company Ltd.

++ -- SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ -- Qt-Security score:critical reason:data-parser

++

++ %parser QXmlStreamGrammar

++ %impl           qxmlstreamparser_p.h

++

++ %expect 4

++

++ %token NOTOKEN

++ %token SPACE " "

++ %token LANGLE "<"

++ %token RANGLE ">"

++ %token AMPERSAND "&"

++ %token HASH "#"

++ %token QUOTE "\'"

++ %token DBLQUOTE "\""

++ %token LBRACK "["

++ %token RBRACK "]"

++ %token LPAREN "("

++ %token RPAREN ")"

++ %token PIPE "|"

++ %token EQ "="

++ %token PERCENT "%"

++ %token SLASH "/"

++ %token COLON ":"

++ %token SEMICOLON ";"

++ %token COMMA ","

++ %token DASH "-"

++ %token PLUS "+"

++ %token STAR "*"

++ %token DOT "."

++ %token QUESTIONMARK "?"

++ %token BANG "!"

++ %token LETTER "[a-zA-Z]"

++ %token DIGIT "[0-9]"

++

++ -- after langle_bang

++ %token CDATA_START "[CDATA["

++ %token DOCTYPE "DOCTYPE"

++ %token ELEMENT "ELEMENT"

++ %token ATTLIST "ATTLIST"

++ %token ENTITY "ENTITY"

++ %token NOTATION "NOTATION"

++

++ -- entity decl

++ %token SYSTEM "SYSTEM"

++ %token PUBLIC "PUBLIC"

++ %token NDATA "NDATA"

++

++ -- default decl

++ %token REQUIRED "REQUIRED"

++ %token IMPLIED "IMPLIED"

++ %token FIXED "FIXED"

++

++ -- content spec

++ %token EMPTY "EMPTY"

++ %token ANY "ANY"

++ %token PCDATA "PCDATA"

++

++ -- error

++ %token XML_ERROR

++

++ -- entities

++ %token PARSE_ENTITY

++ %token ENTITY_DONE

++ %token UNRESOLVED_ENTITY

++

++ -- att type

++ %token CDATA "CDATA"

++ %token ID "ID"

++ %token IDREF "IDREF"

++ %token IDREFS "IDREFS"

++ %token ENTITY "ENTITY"

++ %token ENTITIES "ENTITIES"

++ %token NMTOKEN "NMTOKEN"

++ %token NMTOKENS "NMTOKENS"

++

++ -- xml declaration

++ %token XML "<?xml"

++ %token VERSION "version"

++

++ %nonassoc SHIFT_THERE

++ %nonassoc AMPERSAND

++           BANG

++           COLON

++           COMMA

++           DASH

++           DBLQUOTE

++           DIGIT

++           DOT

++           ENTITY_DONE

++           EQ

++           HASH

++           LBRACK

++           LETTER

++           LPAREN

++           PERCENT

++           PIPE

++           PLUS

++           QUESTIONMARK

++           QUOTE

++           RANGLE

++           RBRACK

++           RPAREN

++           SEMICOLON

++           SLASH

++           SPACE

++           STAR

++

++ %start document

++

++ /.// Copyright (C) 2020 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:critical reason:data-parser

++

++

++ //

++ //  W A R N I N G

++ //  -------------

++ //

++ // This file is not part of the Qt API.  It exists purely as an

++ // implementation detail.  This header file may change from version to

++ // version without notice, or even be removed.

++ //

++ // We mean it.

++ //

++

++ //

++ //  W A R N I N G

++ //  -------------

++ //

++ // This file is automatically generated from qxmlstream.g.

++ // Changes should be made to that file, not here. Any change to this file will

++ // be lost!

++ //

++ // To regenerate this file, run:

++ //    qlalr --no-debug --no-lines --qt qxmlstream.g

++ //

++

++ #include <QtCore/private/qglobal_p.h>

++ #include <qxmlstream.h>

++ #include "qxmlstream_p.h"

++ #include "qxmlutils_p.h"

++ #include <qstringconverter.h>

++

++ #include <memory>

++

++ #ifndef QXMLSTREAMPARSER_P_H

++ #define QXMLSTREAMPARSER_P_H

++

++ QT_BEGIN_NAMESPACE

++

++ #if QT_CONFIG(xmlstreamreader)

++

++ bool QXmlStreamReaderPrivate::parse()

++ {

++     // cleanup currently reported token

++

++     using namespace Qt::StringLiterals;

++

++     switch (type) {

++     case QXmlStreamReader::StartElement:

++         name.clear();

++         prefix.clear();

++         qualifiedName.clear();

++         namespaceUri.clear();

++         publicNamespaceDeclarations.clear();

++         attributes.clear();

++         if (isEmptyElement) {

++             setType(QXmlStreamReader::EndElement);

++             Tag tag = tagStack_pop();

++             namespaceUri = tag.namespaceDeclaration.namespaceUri;

++             prefix = tag.namespaceDeclaration.prefix;

++             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();

++         Q_FALLTHROUGH();

++     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();

++         if (decoder.isValid() && decoder.hasError()) {

++             raiseWellFormedError(QXmlStream::tr("Encountered incorrectly encoded content."));

++             readBuffer.clear();

++             return false;

++         }

++         Q_FALLTHROUGH();

++     case QXmlStreamReader::EndDocument:

++         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];

++

++     while (true) {

++         if (token == -1 && - TERMINAL_COUNT != action_index[act]) {

++             uint cu = getChar();

++             token = NOTOKEN;

++             token_char = cu == ~0U ? cu : ushort(cu);

++             if ((cu != ~0U) && (cu & 0xff0000)) {

++                 token = cu >> 16;

++             } else switch (token_char) {

++             case 0xfffe:

++             case 0xffff:

++                 token = XML_ERROR;

++                 break;

++             case '\r':

++                 token = SPACE;

++                 if (cu == '\r') {

++                     if ((token_char = filterCarriageReturn())) {

++                         ++lineNumber;

++                         lastLineStart = characterOffset + readBufferPos;

++                         break;

++                     }

++                 } else {

++                     break;

++                 }

++                 Q_FALLTHROUGH();

++             case ~0U: {

++                 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;

++                 Q_FALLTHROUGH();

++             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 + 1 >= stack_size - 1)

++                 reallocateStack();

++             ++tos;

++

++             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) {

++ ./

++

++ document ::= PARSE_ENTITY content;

++ /.

++         case $rule_number:

++             setType(QXmlStreamReader::EndDocument);

++         break;

++ ./

++

++ document ::= prolog;

++ /.

++         case $rule_number:

++             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;

++ ./

++

++

++ prolog ::= prolog stag content etag;

++ prolog ::= prolog empty_element_tag;

++ prolog ::= prolog comment;

++ prolog ::= prolog xml_decl;

++ prolog ::= prolog processing_instruction;

++ prolog ::= prolog doctype_decl;

++ prolog ::= prolog SPACE;

++ prolog ::=;

++

++ entity_done ::= ENTITY_DONE;

++ /.

++         case $rule_number: {

++             auto reference = entityReferenceStack.pop();

++             auto it = reference.hash->find(reference.name);

++             Q_ASSERT(it != reference.hash->end());

++             it->isCurrentlyReferenced = false;

++             if (entityReferenceStack.isEmpty())

++                 entityLength = 0;

++             clearSym();

++         } break;

++ ./

++

++

++ xml_decl_start ::= XML;

++ /.

++         case $rule_number:

++             if (!scanString(spell[VERSION], VERSION, false) && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++ xml_decl ::= xml_decl_start VERSION space_opt EQ space_opt literal attribute_list_opt QUESTIONMARK RANGLE;

++ /.

++         case $rule_number:

++             setType(QXmlStreamReader::StartDocument);

++             documentVersion = symString(6);

++             startDocument();

++         break;

++ ./

++

++ external_id ::= SYSTEM literal;

++ /.

++         case $rule_number:

++             hasExternalDtdSubset = true;

++             dtdSystemId = symString(2);

++         break;

++ ./

++ external_id ::= PUBLIC public_literal space literal;

++ /.

++         case $rule_number:

++             checkPublicLiteral(symString(2));

++             dtdPublicId = symString(2);

++             dtdSystemId = symString(4);

++             hasExternalDtdSubset = true;

++         break;

++ ./

++ external_id ::=;

++

++ doctype_decl_start ::= langle_bang DOCTYPE qname space;

++ /.

++         case $rule_number:

++             if (!scanPublicOrSystem() && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++             dtdName = symString(3);

++         break;

++ ./

++

++ doctype_decl ::= langle_bang DOCTYPE qname RANGLE;

++ /.

++         case $rule_number:./

++ doctype_decl ::= langle_bang DOCTYPE qname markup space_opt RANGLE;

++ /.

++         case $rule_number:

++             dtdName = symString(3);

++             Q_FALLTHROUGH();

++ ./

++ doctype_decl ::= doctype_decl_start external_id space_opt markup space_opt RANGLE;

++ /.

++         case $rule_number:./

++ doctype_decl ::= doctype_decl_start external_id space_opt RANGLE;

++ /.

++         case $rule_number:

++             setType(QXmlStreamReader::DTD);

++             text = &textBuffer;

++         break;

++ ./

++

++ markup_start ::= LBRACK;

++ /.

++         case $rule_number:

++             scanDtd = true;

++         break;

++ ./

++

++ markup ::= markup_start markup_list RBRACK;

++ /.

++         case $rule_number:

++             scanDtd = false;

++         break;

++ ./

++

++

++ markup_list ::= markup_decl | space | pereference;

++ markup_list ::= markup_list markup_decl | markup_list space | markup_list pereference;

++ markup_list ::=;

++

++ markup_decl ::= element_decl | attlist_decl | entity_decl | entity_done | notation_decl | processing_instruction | comment;

++

++

++ element_decl_start ::= langle_bang ELEMENT qname space;

++ /.

++         case $rule_number:

++             if (!scanString(spell[EMPTY], EMPTY, false)

++                 && !scanString(spell[ANY], ANY, false)

++                 && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++ element_decl ::= element_decl_start content_spec space_opt RANGLE;

++

++

++ content_spec ::= EMPTY | ANY | mixed | children;

++

++ pcdata_start ::= HASH;

++ /.

++         case $rule_number:

++             if (!scanString(spell[PCDATA], PCDATA, false) && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++ pcdata ::= pcdata_start PCDATA;

++

++ questionmark_or_star_or_plus_opt ::= QUESTIONMARK | STAR | PLUS;

++ questionmark_or_star_or_plus_opt ::=;

++

++ cp ::= qname questionmark_or_star_or_plus_opt | choice_or_seq questionmark_or_star_or_plus_opt;

++

++ cp_pipe_or_comma_list ::= cp space_opt;

++ cp_pipe_or_comma_list ::= cp space_opt PIPE space_opt cp_pipe_list space_opt;

++ cp_pipe_or_comma_list ::= cp space_opt COMMA space_opt cp_comma_list space_opt;

++ cp_pipe_list ::= cp | cp_pipe_list space_opt PIPE space_opt cp;

++ cp_comma_list ::= cp | cp_comma_list space_opt COMMA space_opt cp;

++

++

++ name_pipe_list ::= PIPE space_opt qname;

++ name_pipe_list ::= name_pipe_list space_opt PIPE space_opt qname;

++

++ star_opt ::= | STAR;

++

++ mixed ::= LPAREN space_opt pcdata space_opt RPAREN star_opt;

++ mixed ::= LPAREN space_opt pcdata space_opt name_pipe_list space_opt RPAREN STAR;

++

++ choice_or_seq ::= LPAREN space_opt cp_pipe_or_comma_list RPAREN;

++

++ children ::= choice_or_seq questionmark_or_star_or_plus_opt;

++

++

++ nmtoken_pipe_list ::= nmtoken;

++ nmtoken_pipe_list ::= nmtoken_pipe_list space_opt PIPE space_opt nmtoken;

++

++

++ att_type ::= CDATA;

++ /.

++         case $rule_number: {

++             lastAttributeIsCData = true;

++         } break;

++ ./

++ att_type ::= ID | IDREF | IDREFS | ENTITY | ENTITIES | NMTOKEN | NMTOKENS;

++ att_type ::= LPAREN space_opt nmtoken_pipe_list space_opt RPAREN space;

++ att_type ::= NOTATION LPAREN space_opt nmtoken_pipe_list space_opt RPAREN space;

++

++

++ default_declhash ::= HASH;

++ /.

++         case $rule_number:

++             if (!scanAfterDefaultDecl() && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++ default_decl ::= default_declhash REQUIRED;

++ default_decl ::= default_declhash IMPLIED;

++ default_decl ::= attribute_value;

++ default_decl ::= default_declhash FIXED space attribute_value;

++ attdef_start ::= space qname space;

++ /.

++         case $rule_number:

++                 sym(1) = sym(2);

++                 lastAttributeValue.clear();

++                 lastAttributeIsCData = false;

++                 if (!scanAttType() && atEnd) {

++                     resume($rule_number);

++                     return false;

++                 }

++         break;

++ ./

++

++ attdef ::= attdef_start att_type default_decl;

++ /.

++         case $rule_number: {

++             DtdAttribute &dtdAttribute = dtdAttributes.push();

++             dtdAttribute.tagName.clear();

++             dtdAttribute.isCDATA = lastAttributeIsCData;

++             auto symbol = symQName(1);

++             symbol.resetBackingStorage(addToStringStorage(symbol.all()));

++             dtdAttribute.attributePrefix = symbol.prefix();

++             dtdAttribute.attributeName = symbol.localPart();

++             dtdAttribute.attributeQualifiedName = symbol.qname();

++             dtdAttribute.isNamespaceAttribute = (dtdAttribute.attributePrefix == "xmlns"_L1

++                                                  || (dtdAttribute.attributePrefix.isEmpty()

++                                                      && dtdAttribute.attributeName == "xmlns"_L1));

++             if (lastAttributeValue.isNull()) {

++                 dtdAttribute.defaultValue.clear();

++             } else {

++                 if (dtdAttribute.isCDATA)

++                     dtdAttribute.defaultValue = addToStringStorage(lastAttributeValue);

++                 else

++                     dtdAttribute.defaultValue = addToStringStorage(lastAttributeValue.toString().simplified());

++

++             }

++         } break;

++ ./

++

++ attdef_list ::= attdef;

++ attdef_list ::= attdef_list attdef;

++

++ attlist_decl ::= langle_bang ATTLIST qname space_opt RANGLE;

++ attlist_decl ::= langle_bang ATTLIST qname attdef_list space_opt RANGLE;

++ /.

++         case $rule_number: {

++             if (referenceToUnparsedEntityDetected && !standalone)

++                 break;

++             qsizetype n = dtdAttributes.size();

++             XmlStringRef tagName = addToStringStorage(symName(3));

++             while (n--) {

++                 DtdAttribute &dtdAttribute = dtdAttributes[n];

++                 if (!dtdAttribute.tagName.isNull())

++                     break;

++                 dtdAttribute.tagName = tagName;

++                 for (qsizetype 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;

++ ./

++

++ entity_decl_start ::= langle_bang ENTITY name space;

++ /.

++         case $rule_number: {

++             if (!scanPublicOrSystem() && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++             EntityDeclaration &entityDeclaration = entityDeclarations.push();

++             entityDeclaration.clear();

++             entityDeclaration.name = symString(3);

++         } break;

++ ./

++

++ entity_decl_start ::= langle_bang ENTITY PERCENT space name space;

++ /.

++         case $rule_number: {

++             if (!scanPublicOrSystem() && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++             EntityDeclaration &entityDeclaration = entityDeclarations.push();

++             entityDeclaration.clear();

++             entityDeclaration.name = symString(5);

++             entityDeclaration.parameter = true;

++         } break;

++ ./

++

++ entity_decl_external ::= entity_decl_start SYSTEM literal;

++ /.

++         case $rule_number: {

++             if (!scanNData() && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++             EntityDeclaration &entityDeclaration = entityDeclarations.top();

++             entityDeclaration.systemId = symString(3);

++             entityDeclaration.external = true;

++         } break;

++ ./

++

++ entity_decl_external ::= entity_decl_start PUBLIC public_literal space literal;

++ /.

++         case $rule_number: {

++             if (!scanNData() && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++             EntityDeclaration &entityDeclaration = entityDeclarations.top();

++             checkPublicLiteral((entityDeclaration.publicId = symString(3)));

++             entityDeclaration.systemId = symString(5);

++             entityDeclaration.external = true;

++         } break;

++ ./

++

++ entity_decl ::= entity_decl_external NDATA name space_opt RANGLE;

++ /.

++         case $rule_number: {

++             EntityDeclaration &entityDeclaration = entityDeclarations.top();

++             entityDeclaration.notationName = symString(3);

++             if (entityDeclaration.parameter)

++                 raiseWellFormedError(QXmlStream::tr("NDATA in parameter entity declaration."));

++         }

++         Q_FALLTHROUGH();

++ ./

++

++ entity_decl ::= entity_decl_external space_opt RANGLE;

++ /.

++         case $rule_number:./

++

++ entity_decl ::= entity_decl_start entity_value space_opt RANGLE;

++ /.

++         case $rule_number: {

++             if (referenceToUnparsedEntityDetected && !standalone) {

++                 entityDeclarations.pop();

++                 break;

++             }

++             EntityDeclaration &entityDeclaration = entityDeclarations.top();

++             if (!entityDeclaration.external)

++                 entityDeclaration.value = symString(2);

++             auto &hash = entityDeclaration.parameter ? parameterEntityHash : entityHash;

++             if (!hash.contains(entityDeclaration.name)) {

++                 Entity entity(entityDeclaration.name.toString(),

++                               entityDeclaration.value.toString());

++                 entity.unparsed = (!entityDeclaration.notationName.isNull());

++                 entity.external = entityDeclaration.external;

++                 hash.insert(qToStringViewIgnoringNull(entity.name), entity);

++             }

++         } break;

++ ./

++

++

++ processing_instruction ::= LANGLE QUESTIONMARK name space;

++ /.

++         case $rule_number: {

++             setType(QXmlStreamReader::ProcessingInstruction);

++             const qsizetype pos = sym(4).pos + sym(4).len;

++             processingInstructionTarget = symString(3);

++             if (scanUntil("?>")) {

++                 processingInstructionData = XmlStringRef(&textBuffer, pos, textBuffer.size() - pos - 2);

++                 if (!processingInstructionTarget.view().compare("xml"_L1, Qt::CaseInsensitive)) {

++                     raiseWellFormedError(QXmlStream::tr("XML declaration not at start of document."));

++                 }

++                 else if (!QXmlUtils::isNCName(processingInstructionTarget))

++                     raiseWellFormedError(QXmlStream::tr("%1 is an invalid processing instruction name.")

++                                          .arg(processingInstructionTarget));

++             } else if (type != QXmlStreamReader::Invalid){

++                 resume($rule_number);

++                 return false;

++             }

++         } break;

++ ./

++

++ processing_instruction ::= LANGLE QUESTIONMARK name QUESTIONMARK RANGLE;

++ /.

++         case $rule_number:

++             setType(QXmlStreamReader::ProcessingInstruction);

++             processingInstructionTarget = symString(3);

++             if (!processingInstructionTarget.view().compare("xml"_L1, Qt::CaseInsensitive))

++                 raiseWellFormedError(QXmlStream::tr("Invalid processing instruction name."));

++         break;

++ ./

++

++

++ langle_bang ::= LANGLE BANG;

++ /.

++         case $rule_number:

++             if (!scanAfterLangleBang() && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++ comment_start ::= langle_bang DASH DASH;

++ /.

++         case $rule_number:

++             if (!scanUntil("--")) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++ comment ::= comment_start RANGLE;

++ /.

++         case $rule_number: {

++             setType(QXmlStreamReader::Comment);

++             const qsizetype pos = sym(1).pos + 4;

++             text = XmlStringRef(&textBuffer, pos, textBuffer.size() - pos - 3);

++         } break;

++ ./

++

++

++ cdata ::= langle_bang CDATA_START;

++ /.

++         case $rule_number: {

++             setType(QXmlStreamReader::Characters);

++             isCDATA = true;

++             isWhitespace = false;

++             const qsizetype pos = sym(2).pos;

++             if (scanUntil("]]>", -1)) {

++                 text = XmlStringRef(&textBuffer, pos, textBuffer.size() - pos - 3);

++             } else {

++                 resume($rule_number);

++                 return false;

++             }

++         } break;

++ ./

++

++ notation_decl_start ::= langle_bang NOTATION name space;

++ /.

++         case $rule_number: {

++             if (!scanPublicOrSystem() && atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++             NotationDeclaration &notationDeclaration = notationDeclarations.push();

++             notationDeclaration.name = symString(3);

++         } break;

++ ./

++

++ notation_decl ::= notation_decl_start SYSTEM literal space_opt RANGLE;

++ /.

++         case $rule_number: {

++             NotationDeclaration &notationDeclaration = notationDeclarations.top();

++             notationDeclaration.systemId = symString(3);

++             notationDeclaration.publicId.clear();

++         } break;

++ ./

++

++ notation_decl ::= notation_decl_start PUBLIC public_literal space_opt RANGLE;

++ /.

++         case $rule_number: {

++             NotationDeclaration &notationDeclaration = notationDeclarations.top();

++             notationDeclaration.systemId.clear();

++             checkPublicLiteral((notationDeclaration.publicId = symString(3)));

++         } break;

++ ./

++

++ notation_decl ::= notation_decl_start PUBLIC public_literal space literal space_opt RANGLE;

++ /.

++         case $rule_number: {

++             NotationDeclaration &notationDeclaration = notationDeclarations.top();

++             checkPublicLiteral((notationDeclaration.publicId = symString(3)));

++             notationDeclaration.systemId = symString(5);

++         } break;

++ ./

++

++

++

++ content_char ::= RANGLE | HASH | LBRACK | RBRACK | LPAREN | RPAREN | PIPE | EQ | PERCENT | SLASH | COLON | SEMICOLON | COMMA | DASH | PLUS | STAR | DOT | QUESTIONMARK | BANG | QUOTE | DBLQUOTE | LETTER | DIGIT;

++

++ scan_content_char ::= content_char;

++ /.

++         case $rule_number:

++             isWhitespace = false;

++             Q_FALLTHROUGH();

++ ./

++

++ scan_content_char ::= SPACE;

++ /.

++         case $rule_number:

++             sym(1).len += fastScanContentCharList();

++             if (atEnd && !inParseEntity) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++ content_char_list ::= content_char_list char_ref;

++ content_char_list ::= content_char_list entity_ref;

++ content_char_list ::= content_char_list entity_done;

++ content_char_list ::= content_char_list scan_content_char;

++ content_char_list ::= char_ref;

++ content_char_list ::= entity_ref;

++ content_char_list ::= entity_done;

++ content_char_list ::= scan_content_char;

++

++

++ character_content ::= content_char_list %prec SHIFT_THERE;

++ /.

++         case $rule_number:

++             if (!textBuffer.isEmpty()) {

++                 setType(QXmlStreamReader::Characters);

++                 text = &textBuffer;

++             }

++         break;

++ ./

++

++ literal ::= QUOTE QUOTE;

++ /.

++         case $rule_number:./

++ literal ::= DBLQUOTE DBLQUOTE;

++ /.

++         case $rule_number:

++             clearSym();

++         break;

++ ./

++ literal ::= QUOTE literal_content_with_dblquote QUOTE;

++ /.

++         case $rule_number:./

++ literal ::= DBLQUOTE literal_content_with_quote DBLQUOTE;

++ /.

++         case $rule_number:

++             sym(1) = sym(2);

++         break;

++ ./

++

++ literal_content_with_dblquote ::= literal_content_with_dblquote literal_content;

++ /.

++         case $rule_number:./

++ literal_content_with_quote ::= literal_content_with_quote literal_content;

++ /.

++         case $rule_number:./

++ literal_content_with_dblquote ::= literal_content_with_dblquote DBLQUOTE;

++ /.

++         case $rule_number:./

++ literal_content_with_quote ::= literal_content_with_quote QUOTE;

++ /.

++         case $rule_number:

++             sym(1).len += sym(2).len;

++         break;

++ ./

++ literal_content_with_dblquote ::= literal_content;

++ literal_content_with_quote ::= literal_content;

++ literal_content_with_dblquote ::= DBLQUOTE;

++ literal_content_with_quote ::= QUOTE;

++

++ literal_content_start ::= LETTER | DIGIT | RANGLE | HASH | LBRACK | RBRACK | LPAREN | RPAREN | PIPE | EQ | PERCENT | SLASH | COLON | SEMICOLON | COMMA | DASH | PLUS | STAR | DOT | QUESTIONMARK | BANG;

++

++ literal_content_start ::= SPACE;

++ /.

++         case $rule_number:

++             if (normalizeLiterals)

++                 textBuffer.data()[textBuffer.size()-1] = u' ';

++         break;

++ ./

++

++ literal_content ::= literal_content_start;

++ /.

++         case $rule_number:

++             sym(1).len += fastScanLiteralContent();

++             if (atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++

++ public_literal ::= literal;

++ /.

++         case $rule_number: {

++             if (!QXmlUtils::isPublicID(symString(1))) {

++                 raiseWellFormedError(QXmlStream::tr("%1 is an invalid PUBLIC identifier.").arg(symString(1)));

++                 resume($rule_number);

++                 return false;

++             }

++         } break;

++ ./

++

++ entity_value ::= QUOTE QUOTE;

++ /.

++         case $rule_number:./

++ entity_value ::= DBLQUOTE DBLQUOTE;

++ /.

++         case $rule_number:

++             clearSym();

++         break;

++ ./

++

++ entity_value ::= QUOTE entity_value_content_with_dblquote QUOTE;

++ /.

++         case $rule_number:./

++ entity_value ::= DBLQUOTE entity_value_content_with_quote DBLQUOTE;

++ /.

++         case $rule_number:

++             sym(1) = sym(2);

++         break;

++ ./

++

++ entity_value_content_with_dblquote ::= entity_value_content_with_dblquote entity_value_content;

++ /.

++         case $rule_number:./

++ entity_value_content_with_quote ::= entity_value_content_with_quote entity_value_content;

++ /.

++         case $rule_number:./

++ entity_value_content_with_dblquote ::= entity_value_content_with_dblquote DBLQUOTE;

++ /.

++         case $rule_number:./

++ entity_value_content_with_quote ::= entity_value_content_with_quote QUOTE;

++ /.

++         case $rule_number:

++             sym(1).len += sym(2).len;

++         break;

++ ./

++ entity_value_content_with_dblquote ::= entity_value_content;

++ entity_value_content_with_quote ::= entity_value_content;

++ entity_value_content_with_dblquote ::= DBLQUOTE;

++ entity_value_content_with_quote ::= QUOTE;

++

++ entity_value_content ::= LETTER | DIGIT | LANGLE | RANGLE | HASH | LBRACK | RBRACK | LPAREN | RPAREN | PIPE | EQ | SLASH | COLON | SEMICOLON | COMMA | SPACE | DASH | PLUS | STAR | DOT | QUESTIONMARK | BANG;

++ entity_value_content ::= char_ref | entity_ref_in_entity_value | entity_done;

++

++

++ attribute_value ::= QUOTE QUOTE;

++ /.

++         case $rule_number:./

++ attribute_value ::= DBLQUOTE DBLQUOTE;

++ /.

++         case $rule_number:

++             clearSym();

++         break;

++ ./

++ attribute_value ::= QUOTE attribute_value_content_with_dblquote QUOTE;

++ /.

++         case $rule_number:./

++ attribute_value ::= DBLQUOTE attribute_value_content_with_quote DBLQUOTE;

++ /.

++         case $rule_number:

++             sym(1) = sym(2);

++             lastAttributeValue = symString(1);

++         break;

++ ./

++

++ attribute_value_content_with_dblquote ::= attribute_value_content_with_dblquote attribute_value_content;

++ /.

++         case $rule_number:./

++ attribute_value_content_with_quote ::= attribute_value_content_with_quote attribute_value_content;

++ /.

++         case $rule_number:./

++ attribute_value_content_with_dblquote ::= attribute_value_content_with_dblquote DBLQUOTE;

++ /.

++         case $rule_number:./

++ attribute_value_content_with_quote ::= attribute_value_content_with_quote QUOTE;

++ /.

++         case $rule_number:

++             sym(1).len += sym(2).len;

++         break;

++ ./

++ attribute_value_content_with_dblquote ::= attribute_value_content | DBLQUOTE;

++ attribute_value_content_with_quote ::= attribute_value_content | QUOTE;

++

++ attribute_value_content ::= literal_content | char_ref | entity_ref_in_attribute_value | entity_done;

++

++ attribute ::= qname space_opt EQ space_opt attribute_value;

++ /.

++         case $rule_number: {

++             const XmlStringRef prfx = symPrefix(1);

++             if (prfx.isEmpty() && symString(1) == "xmlns"_L1 && namespaceProcessing) {

++                 NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();

++                 namespaceDeclaration.prefix.clear();

++

++                 const XmlStringRef ns(symString(5));

++                 if (ns.view() == "http://www.w3.org/2000/xmlns/"_L1 ||

++                     ns.view() == "http://www.w3.org/XML/1998/namespace"_L1)

++                     raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));

++                 else

++                     namespaceDeclaration.namespaceUri = addToStringStorage(ns);

++             } else {

++                 Attribute &attribute = attributeStack.push();

++                 attribute.key = sym(1);

++                 attribute.value = sym(5);

++

++                 XmlStringRef attributeQualifiedName = symName(1);

++                 bool normalize = false;

++                 for (const DtdAttribute &dtdAttribute : std::as_const(dtdAttributes)) {

++                     if (!dtdAttribute.isCDATA

++                         && dtdAttribute.tagName == qualifiedName

++                         && dtdAttribute.attributeQualifiedName == attributeQualifiedName

++                         ) {

++                         normalize = true;

++                         break;

++                     }

++                 }

++                 if (normalize) {

++                     // normalize attribute value (simplify and trim)

++                     const qsizetype pos = textBuffer.size();

++                     qsizetype n = 0;

++                     bool wasSpace = true;

++                     for (qsizetype 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 (prfx == "xmlns"_L1 && namespaceProcessing) {

++                     NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();

++                     XmlStringRef namespacePrefix = symString(attribute.key);

++                     XmlStringRef namespaceUri = symString(attribute.value);

++                     attributeStack.pop();

++                     if (((namespacePrefix == "xml"_L1)

++                          ^ (namespaceUri == "http://www.w3.org/XML/1998/namespace"_L1))

++                         || namespaceUri == "http://www.w3.org/2000/xmlns/"_L1

++                         || namespaceUri.isEmpty()

++                         || namespacePrefix == "xmlns"_L1)

++                         raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));

++

++                     namespaceDeclaration.prefix = addToStringStorage(namespacePrefix);

++                     namespaceDeclaration.namespaceUri = addToStringStorage(namespaceUri);

++                 }

++             }

++         } break;

++ ./

++

++

++

++ attribute_list_opt ::= | space | space attribute_list space_opt;

++ attribute_list ::= attribute | attribute_list space attribute;

++

++ stag_start ::= LANGLE qname;

++ /.

++         case $rule_number: {

++             normalizeLiterals = true;

++             Tag &tag = tagStack_push();

++             auto symbol = symQName(2);

++             symbol.resetBackingStorage(addToStringStorage(symbol.all()));

++             prefix = tag.namespaceDeclaration.prefix = symbol.prefix();

++             name = tag.name = symbol.localPart();

++             qualifiedName = tag.qualifiedName = symbol.qname();

++             if ((!prefix.isEmpty() && !QXmlUtils::isNCName(prefix)) || !QXmlUtils::isNCName(name))

++                 raiseWellFormedError(QXmlStream::tr("Invalid XML name."));

++         } break;

++ ./

++

++

++ empty_element_tag ::= stag_start attribute_list_opt SLASH RANGLE;

++ /.

++         case $rule_number:

++             isEmptyElement = true;

++             Q_FALLTHROUGH();

++ ./

++

++

++ stag ::= stag_start attribute_list_opt RANGLE;

++ /.

++         case $rule_number:

++             setType(QXmlStreamReader::StartElement);

++             resolveTag();

++             if (tagStack.size() == 1 && hasSeenTag && !inParseEntity)

++                 raiseWellFormedError(QXmlStream::tr("Extra content at end of document."));

++             hasSeenTag = true;

++         break;

++ ./

++

++

++ etag ::= LANGLE SLASH qname space_opt RANGLE;

++ /.

++         case $rule_number: {

++             setType(QXmlStreamReader::EndElement);

++             Tag tag = tagStack_pop();

++

++             namespaceUri = tag.namespaceDeclaration.namespaceUri;

++             prefix = tag.namespaceDeclaration.prefix;

++             name = tag.name;

++             qualifiedName = tag.qualifiedName;

++             if (qualifiedName != symName(3))

++                 raiseWellFormedError(QXmlStream::tr("Opening and ending tag mismatch."));

++         } break;

++ ./

++

++

++ unresolved_entity ::= UNRESOLVED_ENTITY;

++ /.

++         case $rule_number:

++             if (entitiesMustBeDeclared()) {

++                 raiseWellFormedError(QXmlStream::tr("Entity '%1' not declared.").arg(unresolvedEntity));

++                 break;

++             }

++             setType(QXmlStreamReader::EntityReference);

++             name = &unresolvedEntity;

++         break;

++ ./

++

++ entity_ref ::= AMPERSAND name SEMICOLON;

++ /.

++         case $rule_number: {

++             sym(1).len += sym(2).len + 1;

++             QStringView reference = symView(2);

++             if (const auto it = entityHash.find(reference); it != entityHash.end()) {

++                 Entity &entity = *it;

++                 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(&entityHash, entity))

++                         putReplacement(entity.value);

++                     textBuffer.chop(2 + sym(2).len);

++                     clearSym();

++                 }

++                 break;

++             }

++

++             if (entityResolver) {

++                 QString replacementText = resolveUndeclaredEntity(reference.toString());

++                 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;

++ ./

++

++ pereference ::= PERCENT name SEMICOLON;

++ /.

++         case $rule_number: {

++             sym(1).len += sym(2).len + 1;

++             QStringView reference = symView(2);

++             if (const auto it = parameterEntityHash.find(reference); it != parameterEntityHash.end()) {

++                 referenceToParameterEntityDetected = true;

++                 Entity &entity = *it;

++                 if (entity.unparsed || entity.external) {

++                     referenceToUnparsedEntityDetected = true;

++                 } else {

++                     if (referenceEntity(&parameterEntityHash, entity))

++                         putString(entity.value);

++                     textBuffer.chop(2 + sym(2).len);

++                     clearSym();

++                 }

++             } else if (entitiesMustBeDeclared()) {

++                 raiseWellFormedError(QXmlStream::tr("Entity '%1' not declared.").arg(symString(2)));

++             }

++         } break;

++ ./

++

++

++

++ entity_ref_in_entity_value ::= AMPERSAND name SEMICOLON;

++ /.

++         case $rule_number:

++             sym(1).len += sym(2).len + 1;

++         break;

++ ./

++

++ entity_ref_in_attribute_value ::= AMPERSAND name SEMICOLON;

++ /.

++         case $rule_number: {

++             sym(1).len += sym(2).len + 1;

++             QStringView reference = symView(2);

++             if (const auto it = entityHash.find(reference); it != entityHash.end()) {

++                 Entity &entity = *it;

++                 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(&entityHash, entity))

++                     putReplacementInAttributeValue(entity.value);

++                 textBuffer.chop(2 + sym(2).len);

++                 clearSym();

++                 break;

++             }

++

++             if (entityResolver) {

++                 QString replacementText = resolveUndeclaredEntity(reference.toString());

++                 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;

++ ./

++

++ char_ref ::= AMPERSAND HASH char_ref_value SEMICOLON;

++ /.

++         case $rule_number: {

++             if (char32_t s = resolveCharRef(3)) {

++                 putStringLiteral(QChar::fromUcs4(s));

++                 textBuffer.chop(3 + sym(3).len);

++                 clearSym();

++             } else {

++                 raiseWellFormedError(QXmlStream::tr("Invalid character reference."));

++             }

++         } break;

++ ./

++

++

++ char_ref_value ::= LETTER | DIGIT;

++ char_ref_value ::= char_ref_value LETTER;

++ /.

++         case $rule_number:./

++ char_ref_value ::= char_ref_value DIGIT;

++ /.

++         case $rule_number:

++             sym(1).len += sym(2).len;

++         break;

++ ./

++

++

++ content ::= content character_content;

++ content ::= content stag content etag;

++ content ::= content empty_element_tag;

++ content ::= content comment;

++ content ::= content cdata;

++ content ::= content xml_decl;

++ content ::= content processing_instruction;

++ content ::= content doctype_decl;

++ content ::= content unresolved_entity;

++ content ::=  ;

++

++

++ space ::=  SPACE;

++ /.

++         case $rule_number:

++             sym(1).len += fastScanSpace();

++             if (atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++

++ space_opt ::=;

++ space_opt ::= space;

++

++ qname ::= LETTER;

++ /.

++         case $rule_number: {

++             Value &val = sym(1);

++             if (auto res = fastScanName(&val))

++                 val.len += *res;

++             else

++                 return false;

++

++             if (atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++         } break;

++ ./

++

++ name ::= LETTER;

++ /.

++         case $rule_number:

++             if (auto res = fastScanName())

++                 sym(1).len += *res;

++             else

++                 return false;

++

++             if (atEnd) {

++                 resume($rule_number);

++                 return false;

++             }

++         break;

++ ./

++

++ nmtoken ::= LETTER;

++ /.

++         case $rule_number:./

++ nmtoken ::= DIGIT;

++ /.

++         case $rule_number:./

++ nmtoken ::= DOT;

++ /.

++         case $rule_number:./

++ nmtoken ::= DASH;

++ /.

++         case $rule_number:./

++ nmtoken ::= COLON;

++ /.

++         case $rule_number:

++             sym(1).len += fastScanNMTOKEN();

++             if (atEnd) {

++                 resume($rule_number);

++                 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 // feature xmlstreamreader

++

++ QT_END_NAMESPACE

++

++ #endif

++

++ ./

Revision control