QXmlSimpleReaderPrivate Class Reference

Classes
struct	ExternEntity
struct	ExternParameterEntity
struct	ParseState
struct	XmlRef

Public Functions
	~QXmlSimpleReaderPrivate ()

Private Types
enum	EntityRecognitionContext { InContent, InAttributeValue, InEntityValue, InDTD }
typedef bool(QXmlSimpleReaderPrivate::*	ParseFunction) ()
enum	Standalone { Yes, No, Unknown }

Private Functions
bool	atEnd ()
bool	eat_ws ()
bool	entityExist (const QString &) const
void	init (const QXmlInputSource *i)
void	initData ()
void	initIncrementalParsing ()
bool	insertXmlRef (const QString &, const QString &, bool)
bool	isExpandedEntityValueTooLarge (QString *errorMessage)
const QString &	name ()
void	nameAddC (QChar)
void	nameAddC ()
void	nameClear ()
void QT_FASTCALL	next ()
bool	next_eat_ws ()
bool	parseAttlistDecl ()
bool	parseAttribute ()
bool	parseAttType ()
bool	parseAttValue ()
bool	parseBeginOrContinue (int state, bool incremental)
bool	parseChoiceSeq ()
bool	parseComment ()
bool	parseContent ()
bool	parseDoctype ()
bool	parseElement ()
bool	parseElementDecl ()
bool	parseEntityDecl ()
bool	parseEntityValue ()
bool	parseExternalID ()
void	parseFailed (ParseFunction where, int state)
bool	parseMarkupdecl ()
bool	parseMisc ()
bool	parseName ()
bool	parseNmtoken ()
bool	parseNotationDecl ()
bool	parsePEReference ()
bool	parsePI ()
bool	parseProlog ()
bool	parseReference ()
bool	parseString ()
bool	processElementAttribute ()
bool	processElementEmptyTag ()
bool	processElementETagBegin2 ()
bool	processReference ()
void	pushParseState (ParseFunction function, int state)
	QXmlSimpleReaderPrivate (QXmlSimpleReader *reader)
const QString &	ref ()
void	refAddC (QChar)
void	refAddC ()
void	refClear ()
bool	reportEndEntities ()
void	reportParseError (const QString &error)
const QString &	string ()
void	stringAddC (QChar)
void	stringAddC ()
void	stringClear ()
void	unexpectedEof (ParseFunction where, int state)

Properties
QString	attDeclAName
QString	attDeclEName
QXmlAttributes	attList
QChar	c
int	columnNr
bool	contentCharDataRead
QXmlContentHandler *	contentHnd
QXmlDeclHandler *	declHnd
QString	doctype
bool	doctype_read
signed char	Done
QXmlDTDHandler *	dtdHnd
QString	emptyStr
QString	encoding
QMap< QString, QString >	entities
QXmlEntityResolver *	entityRes
QString	error
QXmlErrorHandler *	errorHnd
QHash< QString, int >	expandedSizes
QMap< QString, ExternEntity >	externEntities
QMap< QString, ExternParameterEntity >	externParameterEntities
QXmlInputSource *	inputSource
QXmlLexicalHandler *	lexicalHnd
int	lineNr
QHash< QString, int >	literalEntitySizes
QScopedPointer< QXmlLocator >	locator
QChar	nameArray [256]
int	nameArrayPos
QXmlNamespaceSupport	namespaceSupport
QString	nameValue
int	nameValueLen
QMap< QString, QString >	parameterEntities
bool	parseExternalID_allowPublicID
bool	parseName_useRef
EntityRecognitionContext	parsePEReference_context
bool	parsePI_xmldecl
bool	parseReference_charDataRead
EntityRecognitionContext	parseReference_context
QStack< ParseState > *	parseStack
QString	parseString_s
QString	publicId
QXmlSimpleReader *	q_ptr
QChar	refArray [256]
int	refArrayPos
QHash< QString, QHash< QString, int > >	referencesToOtherEntities
QString	refValue
int	refValueLen
bool	reportEntities
bool	reportWhitespaceCharData
Standalone	standalone
bool	startDTDwasReported
QChar	stringArray [256]
int	stringArrayPos
QString	stringValue
int	stringValueLen
QString	systemId
QStack< QString >	tags
QString	thisPublicId
QString	thisSystemId
bool	useNamespacePrefixes
bool	useNamespaces
bool	xmldecl_possible
QStack< XmlRef >	xmlRefStack
QString	xmlVersion

Static Private Attributes
static const int	dtdRecursionLimit = 2
static const int	entityCharacterLimit = 1024

Friends
class	QXmlSimpleReaderLocator

Detailed Description

Definition at line 274 of file qxml.cpp.

Typedefs

ParseFunction

typedef bool(QXmlSimpleReaderPrivate::* QXmlSimpleReaderPrivate::ParseFunction) ()

private

Definition at line 502 of file qxml.cpp.

Enumerations

EntityRecognitionContext

enum QXmlSimpleReaderPrivate::EntityRecognitionContext

private

Enumerator
InContent
InAttributeValue
InEntityValue
InDTD

Definition at line 287 of file qxml.cpp.

{ InContent, InAttributeValue, InEntityValue, InDTD };

Standalone

enum QXmlSimpleReaderPrivate::Standalone

private

Enumerator
Yes
No
Unknown

Definition at line 330 of file qxml.cpp.

{ Yes, No, Unknown };

Constructors and Destructors

~QXmlSimpleReaderPrivate()

QXmlSimpleReaderPrivate::~QXmlSimpleReaderPrivate

(

)

Definition at line 3049 of file qxml.cpp.

{
    delete parseStack;
}

QXmlSimpleReaderPrivate()

QXmlSimpleReaderPrivate::QXmlSimpleReaderPrivate ( QXmlSimpleReader *  reader )

private

Definition at line 3029 of file qxml.cpp.

{
    q_ptr = reader;
    parseStack = 0;

    locator.reset(new QXmlSimpleReaderLocator(reader));
    entityRes  = 0;
    dtdHnd     = 0;
    contentHnd = 0;
    errorHnd   = 0;
    lexicalHnd = 0;
    declHnd    = 0;

    // default feature settings
    useNamespaces = true;
    useNamespacePrefixes = false;
    reportWhitespaceCharData = true;
    reportEntities = false;
}

Functions

atEnd()

bool QXmlSimpleReaderPrivate::atEnd ( )

inlineprivate

Definition at line 3010 of file qxml.cpp.

{
    return (c.unicode()|0x0001) == 0xffff;
}

eat_ws()

bool QXmlSimpleReaderPrivate::eat_ws ( )

private

Definition at line 8343 of file qxml.cpp.

Referenced by parseAttlistDecl(), parseAttribute(), parseAttType(), parseAttValue(), parseChoiceSeq(), parseComment(), parseContent(), parseDoctype(), parseElement(), parseElementDecl(), parseEntityDecl(), parseEntityValue(), parseExternalID(), parseMarkupdecl(), parseMisc(), parseName(), parseNmtoken(), parseNotationDecl(), parsePEReference(), parsePI(), parseProlog(), parseReference(), and parseString().

{
    while (!atEnd()) {
        if (!is_S(c)) {
            return true;
        }
        next();
    }
    if (parseStack != 0) {
        unexpectedEof(&QXmlSimpleReaderPrivate::eat_ws, 0);
        return false;
    }
    return true;
}

entityExist()

bool QXmlSimpleReaderPrivate::entityExist ( const QString &  e ) const

private

Definition at line 8405 of file qxml.cpp.

{
    if ( parameterEntities.find(e) == parameterEntities.end() &&
          externParameterEntities.find(e) == externParameterEntities.end() &&
          externEntities.find(e) == externEntities.end() &&
          entities.find(e) == entities.end()) {
        return false;
    } else {
        return true;
    }
}

init()

void QXmlSimpleReaderPrivate::init ( const QXmlInputSource *  i )

private

Definition at line 8369 of file qxml.cpp.

{
    lineNr = 0;
    columnNr = -1;
    inputSource = const_cast<QXmlInputSource *>(i);
    initData();

    externParameterEntities.clear();
    parameterEntities.clear();
    externEntities.clear();
    entities.clear();

    tags.clear();

    doctype.clear();
    xmlVersion.clear();
    encoding.clear();
    standalone = QXmlSimpleReaderPrivate::Unknown;
    error.clear();
}

initData()

void QXmlSimpleReaderPrivate::initData ( )

private

Definition at line 8394 of file qxml.cpp.

{
    c = QXmlInputSource::EndOfData;
    xmlRefStack.clear();
    next();
}

initIncrementalParsing()

void QXmlSimpleReaderPrivate::initIncrementalParsing ( )

private

Definition at line 3054 of file qxml.cpp.

{
    if(parseStack)
        parseStack->clear();
    else
        parseStack = new QStack<ParseState>;
}

insertXmlRef()

bool QXmlSimpleReaderPrivate::insertXmlRef ( const QString &  data, const QString &  name, bool  inLiteral  )

private

Definition at line 8273 of file qxml.cpp.

{
    if (inLiteral) {
        QString tmp = data;
        xmlRefStack.push(XmlRef(name, tmp.replace(QLatin1Char('\"'),
                            QLatin1String(""")).replace(QLatin1Char('\''), QLatin1String("'"))));
    } else {
        xmlRefStack.push(XmlRef(name, data));
    }
    int n = qMax(parameterEntities.count(), entities.count());
    if (xmlRefStack.count() > n+1) {
        // recursive entities
        reportParseError(QLatin1String(XMLERR_RECURSIVEENTITIES));
        return false;
    }
    if (reportEntities && lexicalHnd) {
        if (!lexicalHnd->startEntity(name)) {
            reportParseError(lexicalHnd->errorString());
            return false;
        }
    }
    return true;
}

isExpandedEntityValueTooLarge()

bool QXmlSimpleReaderPrivate::isExpandedEntityValueTooLarge ( QString *  errorMessage )

private

Definition at line 6945 of file qxml.cpp.

{
    QString entityNameBuffer;

    // For every entity, check how many times all entity names were referenced in its value.
    for (QMap<QString,QString>::const_iterator toSearchIt = entities.constBegin();
         toSearchIt != entities.constEnd();
         ++toSearchIt) {
        const QString &toSearch = toSearchIt.key();

        // Don't check the same entities twice.
        if (!literalEntitySizes.contains(toSearch)) {
            // The amount of characters that weren't entity names, but literals, like 'X'.
            QString leftOvers = entities.value(toSearch);
            // How many times was entityName referenced by toSearch?
            for (QMap<QString,QString>::const_iterator referencedIt = entities.constBegin();
                 referencedIt != entities.constEnd();
                 ++referencedIt) {
                const QString &entityName = referencedIt.key();

                for (int i = 0; i < leftOvers.size() && i != -1; ) {
                    entityNameBuffer = QLatin1Char('&') + entityName + QLatin1Char(';');

                    i = leftOvers.indexOf(entityNameBuffer, i);
                    if (i != -1) {
                        leftOvers.remove(i, entityName.size() + 2);
                        // The entityName we're currently trying to find was matched in this string; increase our count.
                        ++referencesToOtherEntities[toSearch][entityName];
                    }
                }
            }
            literalEntitySizes[toSearch] = leftOvers.size();
        }
    }

    for (QHash<QString, QHash<QString, int> >::const_iterator entityIt = referencesToOtherEntities.constBegin();
         entityIt != referencesToOtherEntities.constEnd();
         ++entityIt) {
        const QString &entity = entityIt.key();

        QHash<QString, int>::iterator expandedIt = expandedSizes.find(entity);
        if (expandedIt == expandedSizes.end()) {
            expandedIt = expandedSizes.insert(entity, literalEntitySizes.value(entity));
            for (QHash<QString, int>::const_iterator referenceIt = entityIt->constBegin();
                 referenceIt != entityIt->constEnd();
                 ++referenceIt) {
                const QString &referenceTo = referenceIt.key();
                const int references = referencesToOtherEntities.value(entity).value(referenceTo);
                // The total size of an entity's value is the expanded size of all of its referenced entities, plus its literal size.
                *expandedIt += expandedSizes.value(referenceTo) * references + literalEntitySizes.value(referenceTo) * references;
            }

            if (*expandedIt > entityCharacterLimit) {
                if (errorMessage) {
                    *errorMessage = QString::fromLatin1("The XML entity \"%1\" expands to a string that is too large to process (%2 characters > %3).")
                        .arg(entity, *expandedIt, entityCharacterLimit);
                }
                return true;
            }
        }
    }
    return false;
}

name()

const QString & QXmlSimpleReaderPrivate::name ( )

private

Definition at line 8495 of file qxml.cpp.

Referenced by processElementAttribute(), and processElementETagBegin2().

{
    updateValue(nameValue, nameArray, nameArrayPos, nameValueLen);
    return nameValue;
}

nameAddC() [1/2]

void QXmlSimpleReaderPrivate::nameAddC ( QChar  ch )

private

Definition at line 8512 of file qxml.cpp.

{
    if (nameArrayPos == 256)
        updateValue(nameValue, nameArray, nameArrayPos, nameValueLen);
    nameArray[nameArrayPos++] = ch;
}

nameAddC() [2/2]

void QXmlSimpleReaderPrivate::nameAddC ( )

inlineprivate

Definition at line 445 of file qxml.cpp.

Referenced by nameAddC().

{ nameAddC(c); }

nameClear()

void QXmlSimpleReaderPrivate::nameClear ( )

inlineprivate

Definition at line 3019 of file qxml.cpp.

{
    nameValueLen = 0; nameArrayPos = 0;
}

next()

void QXmlSimpleReaderPrivate::next ( )

private

Definition at line 8300 of file qxml.cpp.

{
    int count = xmlRefStack.size();
    while (count != 0) {
        if (xmlRefStack.top().isEmpty()) {
            xmlRefStack.pop_back();
            count--;
        } else {
            c = xmlRefStack.top().next();
            return;
        }
    }

    // the following could be written nicer, but since it is a time-critical
    // function, rather optimize for speed
    ushort uc = c.unicode();
    c = inputSource->next();
    // If we are not incremental parsing, we just skip over EndOfData chars to give the
    // parser an uninterrupted stream of document chars.
    if (c == QXmlInputSource::EndOfData && parseStack == 0)
        c = inputSource->next();
    if (uc == '\n') {
        lineNr++;
        columnNr = -1;
    } else if (uc == '\r') {
        if (c != QLatin1Char('\n')) {
            lineNr++;
            columnNr = -1;
        }
    }
    ++columnNr;
}

next_eat_ws()

bool QXmlSimpleReaderPrivate::next_eat_ws ( )

private

Definition at line 8358 of file qxml.cpp.

{
    next();
    return eat_ws();
}

parseAttlistDecl()

bool QXmlSimpleReaderPrivate::parseAttlistDecl ( )

private

Definition at line 5867 of file qxml.cpp.

{
    const signed char Init             =  0;
    const signed char Attlist          =  1; // parse the string "ATTLIST"
    const signed char Ws               =  2; // whitespace read
    const signed char Name             =  3; // parse name
    const signed char Ws1              =  4; // whitespace read
    const signed char Attdef           =  5; // parse the AttDef
    const signed char Ws2              =  6; // whitespace read
    const signed char Atttype          =  7; // parse the AttType
    const signed char Ws3              =  8; // whitespace read
    const signed char DDecH            =  9; // DefaultDecl with #
    const signed char DefReq           = 10; // parse the string "REQUIRED"
    const signed char DefImp           = 11; // parse the string "IMPLIED"
    const signed char DefFix           = 12; // parse the string "FIXED"
    const signed char Attval           = 13; // parse the AttValue
    const signed char Ws4              = 14; // whitespace read
    const signed char Done             = 15;

    const signed char InpWs            = 0; // white space
    const signed char InpGt            = 1; // >
    const signed char InpHash          = 2; // #
    const signed char InpA             = 3; // A
    const signed char InpI             = 4; // I
    const signed char InpF             = 5; // F
    const signed char InpR             = 6; // R
    const signed char InpUnknown       = 7;

    static const signed char table[15][8] = {
     /*  InpWs    InpGt    InpHash  InpA      InpI     InpF     InpR     InpUnknown */
        { -1,      -1,      -1,      Attlist,  -1,      -1,      -1,      -1      }, // Init
        { Ws,      -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // Attlist
        { -1,      -1,      -1,      Name,     Name,    Name,    Name,    Name    }, // Ws
        { Ws1,     Done,    Attdef,  Attdef,   Attdef,  Attdef,  Attdef,  Attdef  }, // Name
        { -1,      Done,    Attdef,  Attdef,   Attdef,  Attdef,  Attdef,  Attdef  }, // Ws1
        { Ws2,     -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // Attdef
        { -1,      Atttype, Atttype, Atttype,  Atttype, Atttype, Atttype, Atttype }, // Ws2
        { Ws3,     -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // Attype
        { -1,      Attval,  DDecH,   Attval,   Attval,  Attval,  Attval,  Attval  }, // Ws3
        { -1,      -1,      -1,      -1,       DefImp,  DefFix,  DefReq,  -1      }, // DDecH
        { Ws4,     Ws4,     -1,      -1,       -1,      -1,      -1,      -1      }, // DefReq
        { Ws4,     Ws4,     -1,      -1,       -1,      -1,      -1,      -1      }, // DefImp
        { Ws3,     -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // DefFix
        { Ws4,     Ws4,     -1,      -1,       -1,      -1,      -1,      -1      }, // Attval
        { -1,      Done,    Attdef,  Attdef,   Attdef,  Attdef,  Attdef,  Attdef  }  // Ws4
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseAttlistDecl (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Name:
                attDeclEName = name();
                break;
            case Attdef:
                attDeclAName = name();
                break;
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('>')) {
            input = InpGt;
        } else if (c == QLatin1Char('#')) {
            input = InpHash;
        } else if (c == QLatin1Char('A')) {
            input = InpA;
        } else if (c == QLatin1Char('I')) {
            input = InpI;
        } else if (c == QLatin1Char('F')) {
            input = InpF;
        } else if (c == QLatin1Char('R')) {
            input = InpR;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Attlist:
                parseString_s = QLatin1String("ATTLIST");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case Ws:
            case Ws1:
            case Ws2:
            case Ws3:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case Name:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case Attdef:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case Atttype:
                if (!parseAttType()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case DDecH:
                next();
                break;
            case DefReq:
                parseString_s = QLatin1String("REQUIRED");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case DefImp:
                parseString_s = QLatin1String("IMPLIED");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case DefFix:
                parseString_s = QLatin1String("FIXED");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case Attval:
                if (!parseAttValue()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case Ws4:
                if (declHnd) {
                    // ### not all values are computed yet...
                    if (!declHnd->attributeDecl(attDeclEName, attDeclAName, QLatin1String(""), QLatin1String(""), QLatin1String(""))) {
                        reportParseError(declHnd->errorString());
                        return false;
                    }
                }
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
                    return false;
                }
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parseAttribute()

bool QXmlSimpleReaderPrivate::parseAttribute ( )

private

Definition at line 7559 of file qxml.cpp.

{
    const int Init             = 0;
    const int PName            = 1; // parse name
    const int Ws               = 2; // eat ws
    const int Eq               = 3; // the '=' was read
    const int Quotes           = 4; // " or ' were read

    const int InpNameBe        = 0;
    const int InpEq            = 1; // =
    const int InpDq            = 2; // "
    const int InpSq            = 3; // '
    const int InpUnknown       = 4;

    static const int table[4][5] = {
     /*  InpNameBe  InpEq  InpDq    InpSq    InpUnknown */
        { PName,     -1,    -1,      -1,      -1    }, // Init
        { -1,        Eq,    -1,      -1,      Ws    }, // PName
        { -1,        Eq,    -1,      -1,      -1    }, // Ws
        { -1,        -1,    Quotes,  Quotes,  -1    }  // Eq
    };
    int state;
    int input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseAttribute (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Quotes:
                // Done
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseAttribute, state);
            return false;
        }
        if (determineNameChar(c) == NameBeginning) {
            input = InpNameBe;
        } else if (c == QLatin1Char('=')) {
            input = InpEq;
        } else if (c == QLatin1Char('"')) {
            input = InpDq;
        } else if (c == QLatin1Char('\'')) {
            input = InpSq;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case PName:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
                    return false;
                }
                break;
            case Ws:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
                    return false;
                }
                break;
            case Eq:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
                    return false;
                }
                break;
            case Quotes:
                if (!parseAttValue()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
                    return false;
                }
                break;
        }
    }
    return false;
}

parseAttType()

bool QXmlSimpleReaderPrivate::parseAttType ( )

private

Definition at line 6068 of file qxml.cpp.

{
    const signed char Init             =  0;
    const signed char ST               =  1; // StringType
    const signed char TTI              =  2; // TokenizedType starting with 'I'
    const signed char TTI2             =  3; // TokenizedType helpstate
    const signed char TTI3             =  4; // TokenizedType helpstate
    const signed char TTE              =  5; // TokenizedType starting with 'E'
    const signed char TTEY             =  6; // TokenizedType starting with 'ENTITY'
    const signed char TTEI             =  7; // TokenizedType starting with 'ENTITI'
    const signed char N                =  8; // N read (TokenizedType or Notation)
    const signed char TTNM             =  9; // TokenizedType starting with 'NM'
    const signed char TTNM2            = 10; // TokenizedType helpstate
    const signed char NO               = 11; // Notation
    const signed char NO2              = 12; // Notation helpstate
    const signed char NO3              = 13; // Notation helpstate
    const signed char NOName           = 14; // Notation, read name
    const signed char NO4              = 15; // Notation helpstate
    const signed char EN               = 16; // Enumeration
    const signed char ENNmt            = 17; // Enumeration, read Nmtoken
    const signed char EN2              = 18; // Enumeration helpstate
    const signed char ADone            = 19; // almost done (make next and accept)
    const signed char Done             = 20;

    const signed char InpWs            =  0; // whitespace
    const signed char InpOp            =  1; // (
    const signed char InpCp            =  2; //)
    const signed char InpPipe          =  3; // |
    const signed char InpC             =  4; // C
    const signed char InpE             =  5; // E
    const signed char InpI             =  6; // I
    const signed char InpM             =  7; // M
    const signed char InpN             =  8; // N
    const signed char InpO             =  9; // O
    const signed char InpR             = 10; // R
    const signed char InpS             = 11; // S
    const signed char InpY             = 12; // Y
    const signed char InpUnknown       = 13;

    static const signed char table[19][14] = {
     /*  InpWs    InpOp    InpCp    InpPipe  InpC     InpE     InpI     InpM     InpN     InpO     InpR     InpS     InpY     InpUnknown */
        { -1,      EN,      -1,      -1,      ST,      TTE,     TTI,     -1,      N,       -1,      -1,      -1,      -1,      -1     }, // Init
        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // ST
        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    TTI2,    Done,    Done,    Done   }, // TTI
        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    TTI3,    Done,    Done   }, // TTI2
        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTI3
        { -1,      -1,      -1,      -1,      -1,      -1,      TTEI,    -1,      -1,      -1,      -1,      -1,      TTEY,    -1     }, // TTE
        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTEY
        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTEI
        { -1,      -1,      -1,      -1,      -1,      -1,      -1,      TTNM,    -1,      NO,      -1,      -1,      -1,      -1     }, // N
        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    TTNM2,   Done,    Done   }, // TTNM
        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTNM2
        { NO2,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NO
        { -1,      NO3,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NO2
        { NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName }, // NO3
        { NO4,     -1,      ADone,   NO3,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NOName
        { -1,      -1,      ADone,   NO3,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NO4
        { -1,      -1,      ENNmt,   -1,      ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt  }, // EN
        { EN2,     -1,      ADone,   EN,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // ENNmt
        { -1,      -1,      ADone,   EN,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }  // EN2
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseAttType (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case ADone:
                return true;
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseAttType, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('(')) {
            input = InpOp;
        } else if (c == QLatin1Char(')')) {
            input = InpCp;
        } else if (c == QLatin1Char('|')) {
            input = InpPipe;
        } else if (c == QLatin1Char('C')) {
            input = InpC;
        } else if (c == QLatin1Char('E')) {
            input = InpE;
        } else if (c == QLatin1Char('I')) {
            input = InpI;
        } else if (c == QLatin1Char('M')) {
            input = InpM;
        } else if (c == QLatin1Char('N')) {
            input = InpN;
        } else if (c == QLatin1Char('O')) {
            input = InpO;
        } else if (c == QLatin1Char('R')) {
            input = InpR;
        } else if (c == QLatin1Char('S')) {
            input = InpS;
        } else if (c == QLatin1Char('Y')) {
            input = InpY;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case ST:
                parseString_s = QLatin1String("CDATA");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case TTI:
                parseString_s = QLatin1String("ID");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case TTI2:
                parseString_s = QLatin1String("REF");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case TTI3:
                next(); // S
                break;
            case TTE:
                parseString_s = QLatin1String("ENTIT");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case TTEY:
                next(); // Y
                break;
            case TTEI:
                parseString_s = QLatin1String("IES");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case N:
                next(); // N
                break;
            case TTNM:
                parseString_s = QLatin1String("MTOKEN");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case TTNM2:
                next(); // S
                break;
            case NO:
                parseString_s = QLatin1String("OTATION");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case NO2:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case NO3:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case NOName:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case NO4:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case EN:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case ENNmt:
                if (!parseNmtoken()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case EN2:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
                    return false;
                }
                break;
            case ADone:
                next();
                break;
        }
    }
    return false;
}

parseAttValue()

bool QXmlSimpleReaderPrivate::parseAttValue ( )

private

Definition at line 6323 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char Dq               = 1; // double quotes were read
    const signed char DqRef            = 2; // read references in double quotes
    const signed char DqC              = 3; // signed character read in double quotes
    const signed char Sq               = 4; // single quotes were read
    const signed char SqRef            = 5; // read references in single quotes
    const signed char SqC              = 6; // signed character read in single quotes
    const signed char Done             = 7;

    const signed char InpDq            = 0; // "
    const signed char InpSq            = 1; // '
    const signed char InpAmp           = 2; // &
    const signed char InpLt            = 3; // <
    const signed char InpUnknown       = 4;

    static const signed char table[7][5] = {
     /*  InpDq  InpSq  InpAmp  InpLt InpUnknown */
        { Dq,    Sq,    -1,     -1,   -1    }, // Init
        { Done,  DqC,   DqRef,  -1,   DqC   }, // Dq
        { Done,  DqC,   DqRef,  -1,   DqC   }, // DqRef
        { Done,  DqC,   DqRef,  -1,   DqC   }, // DqC
        { SqC,   Done,  SqRef,  -1,   SqC   }, // Sq
        { SqC,   Done,  SqRef,  -1,   SqC   }, // SqRef
        { SqC,   Done,  SqRef,  -1,   SqC   }  // SqRef
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseAttValue (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseAttValue, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseAttValue, state);
            return false;
        }
        if        (c == QLatin1Char('"')) {
            input = InpDq;
        } else if (c == QLatin1Char('\'')) {
            input = InpSq;
        } else if (c == QLatin1Char('&')) {
            input = InpAmp;
        } else if (c == QLatin1Char('<')) {
            input = InpLt;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Dq:
            case Sq:
                stringClear();
                next();
                break;
            case DqRef:
            case SqRef:
                parseReference_context = InAttributeValue;
                if (!parseReference()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseAttValue, state);
                    return false;
                }
                break;
            case DqC:
            case SqC:
                stringAddC();
                next();
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parseBeginOrContinue()

bool QXmlSimpleReaderPrivate::parseBeginOrContinue ( int  state, bool  incremental  )

private

Definition at line 3791 of file qxml.cpp.

{
    bool atEndOrig = atEnd();

    if (state==0) {
        if (!parseProlog()) {
            if (incremental && error.isNull()) {
                pushParseState(0, 0);
                return true;
            } else {
                tags.clear();
                return false;
            }
        }
        state = 1;
    }
    if (state==1) {
        if (!parseElement()) {
            if (incremental && error.isNull()) {
                pushParseState(0, 1);
                return true;
            } else {
                tags.clear();
                return false;
            }
        }
        state = 2;
    }
    // parse Misc*
    while (!atEnd()) {
        if (!parseMisc()) {
            if (incremental && error.isNull()) {
                pushParseState(0, 2);
                return true;
            } else {
                tags.clear();
                return false;
            }
        }
    }
    if (!atEndOrig && incremental) {
        // we parsed something at all, so be prepared to come back later
        pushParseState(0, 2);
        return true;
    }
    // is stack empty?
    if (!tags.isEmpty() && !error.isNull()) {
        reportParseError(QLatin1String(XMLERR_UNEXPECTEDEOF));
        tags.clear();
        return false;
    }
    // call the handler
    if (contentHnd) {
        delete parseStack;
        parseStack = 0;
        if (!contentHnd->endDocument()) {
            reportParseError(contentHnd->errorString());
            return false;
        }
    }
    return true;
}

parseChoiceSeq()

bool QXmlSimpleReaderPrivate::parseChoiceSeq ( )

private

Definition at line 6816 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char Ws1              = 1; // eat whitespace
    const signed char CoS              = 2; // choice or set
    const signed char Ws2              = 3; // eat whitespace
    const signed char More             = 4; // more cp to read
    const signed char Name             = 5; // read name
    const signed char Done             = 6; //

    const signed char InpWs            = 0; // S
    const signed char InpOp            = 1; // (
    const signed char InpCp            = 2; //)
    const signed char InpQm            = 3; // ?
    const signed char InpAst           = 4; // *
    const signed char InpPlus          = 5; // +
    const signed char InpPipe          = 6; // |
    const signed char InpComm          = 7; // ,
    const signed char InpUnknown       = 8;

    static const signed char table[6][9] = {
     /*  InpWs   InpOp  InpCp  InpQm  InpAst  InpPlus  InpPipe  InpComm  InpUnknown */
        { -1,     Ws1,   -1,    -1,    -1,     -1,      -1,      -1,      Name  }, // Init
        { -1,     CoS,   -1,    -1,    -1,     -1,      -1,      -1,      CoS   }, // Ws1
        { Ws2,    -1,    Done,  Ws2,   Ws2,    Ws2,     More,    More,    -1    }, // CS
        { -1,     -1,    Done,  -1,    -1,     -1,      More,    More,    -1    }, // Ws2
        { -1,     Ws1,   -1,    -1,    -1,     -1,      -1,      -1,      Name  }, // More (same as Init)
        { Ws2,    -1,    Done,  Ws2,   Ws2,    Ws2,     More,    More,    -1    }  // Name (same as CS)
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseChoiceSeq (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('(')) {
            input = InpOp;
        } else if (c == QLatin1Char(')')) {
            input = InpCp;
        } else if (c == QLatin1Char('?')) {
            input = InpQm;
        } else if (c == QLatin1Char('*')) {
            input = InpAst;
        } else if (c == QLatin1Char('+')) {
            input = InpPlus;
        } else if (c == QLatin1Char('|')) {
            input = InpPipe;
        } else if (c == QLatin1Char(',')) {
            input = InpComm;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Ws1:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
                    return false;
                }
                break;
            case CoS:
                if (!parseChoiceSeq()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
                    return false;
                }
                break;
            case Ws2:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
                    return false;
                }
                break;
            case More:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
                    return false;
                }
                break;
            case Name:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
                    return false;
                }
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parseComment()

bool QXmlSimpleReaderPrivate::parseComment ( )

private

Definition at line 7445 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char Dash1            = 1; // the first dash was read
    const signed char Dash2            = 2; // the second dash was read
    const signed char Com              = 3; // read comment
    const signed char Com2             = 4; // read comment (help state)
    const signed char ComE             = 5; // finished reading comment
    const signed char Done             = 6;

    const signed char InpDash          = 0; // -
    const signed char InpGt            = 1; // >
    const signed char InpUnknown       = 2;

    static const signed char table[6][3] = {
     /*  InpDash  InpGt  InpUnknown */
        { Dash1,   -1,    -1  }, // Init
        { Dash2,   -1,    -1  }, // Dash1
        { Com2,    Com,   Com }, // Dash2
        { Com2,    Com,   Com }, // Com
        { ComE,    Com,   Com }, // Com2
        { -1,      Done,  -1  }  // ComE
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseComment (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseComment, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Dash2:
                stringClear();
                break;
            case Com2:
                // if next character is not a dash than don't skip it
                if (!atEnd() && c != QLatin1Char('-'))
                    stringAddC(QLatin1Char('-'));
                break;
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_ERRORPARSINGCOMMENT));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseComment, state);
            return false;
        }
        if (c == QLatin1Char('-')) {
            input = InpDash;
        } else if (c == QLatin1Char('>')) {
            input = InpGt;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Dash1:
                next();
                break;
            case Dash2:
                next();
                break;
            case Com:
                stringAddC();
                next();
                break;
            case Com2:
                next();
                break;
            case ComE:
                next();
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parseContent()

bool QXmlSimpleReaderPrivate::parseContent ( )

private

Definition at line 4454 of file qxml.cpp.

{
    const signed char Init             =  0;
    const signed char ChD              =  1; // CharData
    const signed char ChD1             =  2; // CharData help state
    const signed char ChD2             =  3; // CharData help state
    const signed char Ref              =  4; // Reference
    const signed char Lt               =  5; // '<' read
    const signed char PInstr           =  6; // PI
    const signed char PInstrR          =  7; // same as PInstr, but already reported
    const signed char Elem             =  8; // Element
    const signed char Em               =  9; // '!' read
    const signed char Com              = 10; // Comment
    const signed char ComR             = 11; // same as Com, but already reported
    const signed char CDS              = 12; // CDSect
    const signed char CDS1             = 13; // read a CDSect
    const signed char CDS2             = 14; // read a CDSect (help state)
    const signed char CDS3             = 15; // read a CDSect (help state)
    const signed char Done             = 16; // finished reading content

    const signed char InpLt            = 0; // <
    const signed char InpGt            = 1; // >
    const signed char InpSlash         = 2; // /
    const signed char InpQMark         = 3; // ?
    const signed char InpEMark         = 4; // !
    const signed char InpAmp           = 5; // &
    const signed char InpDash          = 6; // -
    const signed char InpOpenB         = 7; // [
    const signed char InpCloseB        = 8; //]
    const signed char InpUnknown       = 9;

    static const signed char mapCLT2FSMChar[] = {
        InpUnknown, // white space
        InpUnknown, // %
        InpAmp,     // &
        InpGt,      // >
        InpLt,      // <
        InpSlash,   // /
        InpQMark,   // ?
        InpEMark,   // !
        InpDash,    // -
        InpCloseB,  //]
        InpOpenB,   // [
        InpUnknown, // =
        InpUnknown, // "
        InpUnknown, // '
        InpUnknown  // unknown
    };

    static const signed char table[16][10] = {
     /*  InpLt  InpGt  InpSlash  InpQMark  InpEMark  InpAmp  InpDash  InpOpenB  InpCloseB  InpUnknown */
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD1,      ChD  }, // Init
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD1,      ChD  }, // ChD
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD2,      ChD  }, // ChD1
        { Lt,    -1,    ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD2,      ChD  }, // ChD2
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // Ref (same as Init)
        { -1,    -1,    Done,     PInstr,   Em,       -1,     -1,      -1,       -1,        Elem }, // Lt
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // PInstr (same as Init)
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // PInstrR
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // Elem (same as Init)
        { -1,    -1,    -1,       -1,       -1,       -1,     Com,     CDS,      -1,        -1   }, // Em
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // Com (same as Init)
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // ComR
        { CDS1,  CDS1,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS2,      CDS1 }, // CDS
        { CDS1,  CDS1,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS2,      CDS1 }, // CDS1
        { CDS1,  CDS1,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS3,      CDS1 }, // CDS2
        { CDS1,  Init,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS3,      CDS1 }  // CDS3
    };
    signed char state;
    signed char input;

    if (parseStack == 0 || parseStack->isEmpty()) {
        contentCharDataRead = false;
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseContent (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Ref:
                if (!contentCharDataRead)
                    contentCharDataRead = parseReference_charDataRead;
                break;
            case PInstr:
                if (contentHnd) {
                    if (!contentHnd->processingInstruction(name(),string())) {
                        reportParseError(contentHnd->errorString());
                        return false;
                    }
                }
                state = PInstrR;
                break;
            case Com:
                if (lexicalHnd) {
                    if (!lexicalHnd->comment(string())) {
                        reportParseError(lexicalHnd->errorString());
                        return false;
                    }
                }
                state = ComR;
                break;
            case CDS:
                stringClear();
                break;
            case CDS2:
                if (!atEnd() && c != QLatin1Char(']'))
                    stringAddC(QLatin1Char(']'));
                break;
            case CDS3:
                // test if this skipping was legal
                if (!atEnd()) {
                    if (c == QLatin1Char('>')) {
                        // the end of the CDSect
                        if (lexicalHnd) {
                            if (!lexicalHnd->startCDATA()) {
                                reportParseError(lexicalHnd->errorString());
                                return false;
                            }
                        }
                        if (contentHnd) {
                            if (!contentHnd->characters(string())) {
                                reportParseError(contentHnd->errorString());
                                return false;
                            }
                        }
                        if (lexicalHnd) {
                            if (!lexicalHnd->endCDATA()) {
                                reportParseError(lexicalHnd->errorString());
                                return false;
                            }
                        }
                    } else if (c == QLatin1Char(']')) {
                        // three or more ']'
                        stringAddC(QLatin1Char(']'));
                    } else {
                        // after ']]' comes another character
                        stringAddC(QLatin1Char(']'));
                        stringAddC(QLatin1Char(']'));
                    }
                }
                break;
            case Done:
                // call the handler for CharData
                if (contentHnd) {
                    if (contentCharDataRead) {
                        if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
                            if (!contentHnd->characters(string())) {
                                reportParseError(contentHnd->errorString());
                                return false;
                            }
                        }
                    }
                }
                // Done
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_ERRORPARSINGCONTENT));
                return false;
        }

        // get input (use lookup-table instead of nested ifs for performance
        // reasons)
        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseContent, state);
            return false;
        }
        if (c.row()) {
            input = InpUnknown;
        } else {
            input = mapCLT2FSMChar[charLookupTable[c.cell()]];
        }
        state = table[state][input];

        switch (state) {
            case Init:
                // skip the ending '>' of a CDATASection
                next();
                break;
            case ChD:
                // on first call: clear string
                if (!contentCharDataRead) {
                    contentCharDataRead = true;
                    stringClear();
                }
                stringAddC();
                if (reportEntities) {
                    if (!reportEndEntities())
                        return false;
                }
                next();
                break;
            case ChD1:
                // on first call: clear string
                if (!contentCharDataRead) {
                    contentCharDataRead = true;
                    stringClear();
                }
                stringAddC();
                if (reportEntities) {
                    if (!reportEndEntities())
                        return false;
                }
                next();
                break;
            case ChD2:
                stringAddC();
                if (reportEntities) {
                    if (!reportEndEntities())
                        return false;
                }
                next();
                break;
            case Ref:
                if (!contentCharDataRead) {
                    // reference may be CharData; so clear string to be safe
                    stringClear();
                    parseReference_context = InContent;
                    if (!parseReference()) {
                        parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
                        return false;
                    }
                } else {
                    if (reportEntities) {
                        // report character data in chunks
                        if (contentHnd) {
                            if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
                                if (!contentHnd->characters(string())) {
                                    reportParseError(contentHnd->errorString());
                                    return false;
                                }
                            }
                        }
                        stringClear();
                    }
                    parseReference_context = InContent;
                    if (!parseReference()) {
                        parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
                        return false;
                    }
                }
                break;
            case Lt:
                // call the handler for CharData
                if (contentHnd) {
                    if (contentCharDataRead) {
                        if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
                            if (!contentHnd->characters(string())) {
                                reportParseError(contentHnd->errorString());
                                return false;
                            }
                        }
                    }
                }
                contentCharDataRead = false;
                next();
                break;
            case PInstr:
            case PInstrR:
                parsePI_xmldecl = false;
                if (!parsePI()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
                    return false;
                }
                break;
            case Elem:
                if (!parseElement()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
                    return false;
                }
                break;
            case Em:
                next();
                break;
            case Com:
            case ComR:
                if (!parseComment()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
                    return false;
                }
                break;
            case CDS:
                parseString_s = QLatin1String("[CDATA[");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
                    return false;
                }
                break;
            case CDS1:
                stringAddC();
                next();
                break;
            case CDS2:
                // skip ']'
                next();
                break;
            case CDS3:
                // skip ']'...
                next();
                break;
        }
    }
    return false;
}

parseDoctype()

bool QXmlSimpleReaderPrivate::parseDoctype ( )

private

Definition at line 5165 of file qxml.cpp.

{
    const signed char Init             =  0;
    const signed char Doctype          =  1; // read the doctype
    const signed char Ws1              =  2; // eat_ws
    const signed char Doctype2         =  3; // read the doctype, part 2
    const signed char Ws2              =  4; // eat_ws
    const signed char Sys              =  5; // read SYSTEM or PUBLIC
    const signed char Ws3              =  6; // eat_ws
    const signed char MP               =  7; // markupdecl or PEReference
    const signed char MPR              =  8; // same as MP, but already reported
    const signed char PER              =  9; // PERReference
    const signed char Mup              = 10; // markupdecl
    const signed char Ws4              = 11; // eat_ws
    const signed char MPE              = 12; // end of markupdecl or PEReference
    const signed char Done             = 13;

    const signed char InpWs            = 0;
    const signed char InpD             = 1; // 'D'
    const signed char InpS             = 2; // 'S' or 'P'
    const signed char InpOB            = 3; // [
    const signed char InpCB            = 4; //]
    const signed char InpPer           = 5; // %
    const signed char InpGt            = 6; // >
    const signed char InpUnknown       = 7;

    static const signed char table[13][8] = {
     /*  InpWs,  InpD       InpS       InpOB  InpCB  InpPer InpGt  InpUnknown */
        { -1,     Doctype,   -1,        -1,    -1,    -1,    -1,    -1        }, // Init
        { Ws1,    -1,        -1,        -1,    -1,    -1,    -1,    -1        }, // Doctype
        { -1,     Doctype2,  Doctype2,  -1,    -1,    -1,    -1,    Doctype2  }, // Ws1
        { Ws2,    -1,        Sys,       MP,    -1,    -1,    Done,  -1        }, // Doctype2
        { -1,     -1,        Sys,       MP,    -1,    -1,    Done,  -1        }, // Ws2
        { Ws3,    -1,        -1,        MP,    -1,    -1,    Done,  -1        }, // Sys
        { -1,     -1,        -1,        MP,    -1,    -1,    Done,  -1        }, // Ws3
        { -1,     -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // MP
        { -1,     -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // MPR
        { Ws4,    -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // PER
        { Ws4,    -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // Mup
        { -1,     -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // Ws4
        { -1,     -1,        -1,        -1,    -1,    -1,    Done,  -1        }  // MPE
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        startDTDwasReported = false;
        systemId.clear();
        publicId.clear();
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseDoctype (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Doctype2:
                doctype = name();
                break;
            case MP:
                if (!startDTDwasReported && lexicalHnd ) {
                    startDTDwasReported = true;
                    if (!lexicalHnd->startDTD(doctype, publicId, systemId)) {
                        reportParseError(lexicalHnd->errorString());
                        return false;
                    }
                }
                state = MPR;
                break;
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_ERRORPARSINGDOCTYPE));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseDoctype, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('D')) {
            input = InpD;
        } else if (c == QLatin1Char('S')) {
            input = InpS;
        } else if (c == QLatin1Char('P')) {
            input = InpS;
        } else if (c == QLatin1Char('[')) {
            input = InpOB;
        } else if (c == QLatin1Char(']')) {
            input = InpCB;
        } else if (c == QLatin1Char('%')) {
            input = InpPer;
        } else if (c == QLatin1Char('>')) {
            input = InpGt;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Doctype:
                parseString_s = QLatin1String("DOCTYPE");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
                    return false;
                }
                break;
            case Ws1:
            case Ws2:
            case Ws3:
            case Ws4:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
                    return false;
                }
                break;
            case Doctype2:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
                    return false;
                }
                break;
            case Sys:
                parseExternalID_allowPublicID = false;
                if (!parseExternalID()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
                    return false;
                }
                thisPublicId = publicId;
                thisSystemId = systemId;
                break;
            case MP:
            case MPR:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
                    return false;
                }
                break;
            case PER:
                parsePEReference_context = InDTD;
                if (!parsePEReference()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
                    return false;
                }
                break;
            case Mup:
                if (dtdRecursionLimit > 0 && parameterEntities.size() > dtdRecursionLimit) {
                    reportParseError(QString::fromLatin1(
                        "DTD parsing exceeded recursion limit of %1.").arg(dtdRecursionLimit));
                    return false;
                }
                if (!parseMarkupdecl()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
                    return false;
                }
                break;
            case MPE:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
                    return false;
                }
                break;
            case Done:
                if (lexicalHnd) {
                    if (!startDTDwasReported) {
                        startDTDwasReported = true;
                        if (!lexicalHnd->startDTD(doctype, publicId, systemId)) {
                            reportParseError(lexicalHnd->errorString());
                            return false;
                        }
                    }
                    if (!lexicalHnd->endDTD()) {
                        reportParseError(lexicalHnd->errorString());
                        return false;
                    }
                }
                next();
                break;
        }
    }
    return false;
}

parseElement()

bool QXmlSimpleReaderPrivate::parseElement ( )

private

Definition at line 4121 of file qxml.cpp.

{
    const int Init             =  0;
    const int ReadName         =  1;
    const int Ws1              =  2;
    const int STagEnd          =  3;
    const int STagEnd2         =  4;
    const int ETagBegin        =  5;
    const int ETagBegin2       =  6;
    const int Ws2              =  7;
    const int EmptyTag         =  8;
    const int Attrib           =  9;
    const int AttribPro        = 10; // like Attrib, but processAttribute was already called
    const int Ws3              = 11;
    const int Done             = 12;

    const int InpWs            = 0; // whitespace
    const int InpNameBe        = 1; // NameBeginning
    const int InpGt            = 2; // >
    const int InpSlash         = 3; // /
    const int InpUnknown       = 4;

    static const int table[12][5] = {
     /*  InpWs      InpNameBe    InpGt        InpSlash     InpUnknown */
        { -1,        ReadName,    -1,          -1,          -1        }, // Init
        { Ws1,       Attrib,      STagEnd,     EmptyTag,    -1        }, // ReadName
        { -1,        Attrib,      STagEnd,     EmptyTag,    -1        }, // Ws1
        { STagEnd2,  STagEnd2,    STagEnd2,    STagEnd2,    STagEnd2  }, // STagEnd
        { -1,        -1,          -1,          ETagBegin,   -1        }, // STagEnd2
        { -1,        ETagBegin2,  -1,          -1,          -1        }, // ETagBegin
        { Ws2,       -1,          Done,        -1,          -1        }, // ETagBegin2
        { -1,        -1,          Done,        -1,          -1        }, // Ws2
        { -1,        -1,          Done,        -1,          -1        }, // EmptyTag
        { Ws3,       Attrib,      STagEnd,     EmptyTag,    -1        }, // Attrib
        { Ws3,       Attrib,      STagEnd,     EmptyTag,    -1        }, // AttribPro
        { -1,        Attrib,      STagEnd,     EmptyTag,    -1        }  // Ws3
    };
    int state;
    int input;

    if (parseStack == 0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseElement (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case ReadName:
                // store it on the stack
                tags.push(name());
                // empty the attributes
                attList.clear();
                if (useNamespaces)
                    namespaceSupport.pushContext();
                break;
            case ETagBegin2:
                if (!processElementETagBegin2())
                    return false;
                break;
            case Attrib:
                if (!processElementAttribute())
                    return false;
                state = AttribPro;
                break;
            case Done:
                return true;
            case -1:
                reportParseError(QLatin1String(XMLERR_ERRORPARSINGELEMENT));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseElement, state);
            return false;
        }
        if (fastDetermineNameChar(c) == NameBeginning) {
            input = InpNameBe;
        } else if (c == QLatin1Char('>')) {
            input = InpGt;
        } else if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('/')) {
            input = InpSlash;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case ReadName:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
                    return false;
                }
                break;
            case Ws1:
            case Ws2:
            case Ws3:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
                    return false;
                }
                break;
            case STagEnd:
                // call the handler
                if (contentHnd) {
                    const QString &tagsTop = tags.top();
                    if (useNamespaces) {
                        QString uri, lname;
                        namespaceSupport.processName(tagsTop, false, uri, lname);
                        if (!contentHnd->startElement(uri, lname, tagsTop, attList)) {
                            reportParseError(contentHnd->errorString());
                            return false;
                        }
                    } else {
                        if (!contentHnd->startElement(QString(), QString(), tagsTop, attList)) {
                            reportParseError(contentHnd->errorString());
                            return false;
                        }
                    }
                }
                next();
                break;
            case STagEnd2:
                if (!parseContent()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
                    return false;
                }
                break;
            case ETagBegin:
                next();
                break;
            case ETagBegin2:
                // get the name of the tag
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
                    return false;
                }
                break;
            case EmptyTag:
                if  (tags.isEmpty()) {
                    reportParseError(QLatin1String(XMLERR_TAGMISMATCH));
                    return false;
                }
                if (!processElementEmptyTag())
                    return false;
                next();
                break;
            case Attrib:
            case AttribPro:
                // get name and value of attribute
                if (!parseAttribute()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
                    return false;
                }
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parseElementDecl()

bool QXmlSimpleReaderPrivate::parseElementDecl ( )

private

Definition at line 6435 of file qxml.cpp.

{
    const signed char Init             =  0;
    const signed char Elem             =  1; // parse the beginning string
    const signed char Ws1              =  2; // whitespace required
    const signed char Nam              =  3; // parse Name
    const signed char Ws2              =  4; // whitespace required
    const signed char Empty            =  5; // read EMPTY
    const signed char Any              =  6; // read ANY
    const signed char Cont             =  7; // read contentspec (except ANY or EMPTY)
    const signed char Mix              =  8; // read Mixed
    const signed char Mix2             =  9; //
    const signed char Mix3             = 10; //
    const signed char MixN1            = 11; //
    const signed char MixN2            = 12; //
    const signed char MixN3            = 13; //
    const signed char MixN4            = 14; //
    const signed char Cp               = 15; // parse cp
    const signed char Cp2              = 16; //
    const signed char WsD              = 17; // eat whitespace before Done
    const signed char Done             = 18;

    const signed char InpWs            =  0;
    const signed char InpGt            =  1; // >
    const signed char InpPipe          =  2; // |
    const signed char InpOp            =  3; // (
    const signed char InpCp            =  4; //)
    const signed char InpHash          =  5; // #
    const signed char InpQm            =  6; // ?
    const signed char InpAst           =  7; // *
    const signed char InpPlus          =  8; // +
    const signed char InpA             =  9; // A
    const signed char InpE             = 10; // E
    const signed char InpL             = 11; // L
    const signed char InpUnknown       = 12;

    static const signed char table[18][13] = {
     /*  InpWs   InpGt  InpPipe  InpOp  InpCp   InpHash  InpQm  InpAst  InpPlus  InpA    InpE    InpL    InpUnknown */
        { -1,     -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     Elem,   -1     }, // Init
        { Ws1,    -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Elem
        { -1,     -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      Nam,    Nam,    Nam,    Nam    }, // Ws1
        { Ws2,    -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Nam
        { -1,     -1,    -1,      Cont,  -1,     -1,      -1,    -1,     -1,      Any,    Empty,  -1,     -1     }, // Ws2
        { WsD,    Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Empty
        { WsD,    Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Any
        { -1,     -1,    -1,      Cp,    Cp,     Mix,     -1,    -1,     -1,      Cp,     Cp,     Cp,     Cp     }, // Cont
        { Mix2,   -1,    MixN1,   -1,    Mix3,   -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Mix
        { -1,     -1,    MixN1,   -1,    Mix3,   -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Mix2
        { WsD,    Done,  -1,      -1,    -1,     -1,      -1,    WsD,    -1,      -1,     -1,     -1,     -1     }, // Mix3
        { -1,     -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      MixN2,  MixN2,  MixN2,  MixN2  }, // MixN1
        { MixN3,  -1,    MixN1,   -1,    MixN4,  -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // MixN2
        { -1,     -1,    MixN1,   -1,    MixN4,  -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // MixN3
        { -1,     -1,    -1,      -1,    -1,     -1,      -1,    WsD,    -1,      -1,     -1,     -1,     -1     }, // MixN4
        { WsD,    Done,  -1,      -1,    -1,     -1,      Cp2,   Cp2,    Cp2,     -1,     -1,     -1,     -1     }, // Cp
        { WsD,    Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Cp2
        { -1,     Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }  // WsD
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseElementDecl (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Done:
                return true;
            case -1:
                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseElementDecl, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('>')) {
            input = InpGt;
        } else if (c == QLatin1Char('|')) {
            input = InpPipe;
        } else if (c == QLatin1Char('(')) {
            input = InpOp;
        } else if (c == QLatin1Char(')')) {
            input = InpCp;
        } else if (c == QLatin1Char('#')) {
            input = InpHash;
        } else if (c == QLatin1Char('?')) {
            input = InpQm;
        } else if (c == QLatin1Char('*')) {
            input = InpAst;
        } else if (c == QLatin1Char('+')) {
            input = InpPlus;
        } else if (c == QLatin1Char('A')) {
            input = InpA;
        } else if (c == QLatin1Char('E')) {
            input = InpE;
        } else if (c == QLatin1Char('L')) {
            input = InpL;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Elem:
                parseString_s = QLatin1String("LEMENT");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Ws1:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Nam:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Ws2:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Empty:
                parseString_s = QLatin1String("EMPTY");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Any:
                parseString_s = QLatin1String("ANY");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Cont:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Mix:
                parseString_s = QLatin1String("#PCDATA");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Mix2:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Mix3:
                next();
                break;
            case MixN1:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case MixN2:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case MixN3:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case MixN4:
                next();
                break;
            case Cp:
                if (!parseChoiceSeq()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Cp2:
                next();
                break;
            case WsD:
                if (!next_eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
                    return false;
                }
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parseEntityDecl()

bool QXmlSimpleReaderPrivate::parseEntityDecl ( )

private

Definition at line 7015 of file qxml.cpp.

{
    const signed char Init             =  0;
    const signed char Ent              =  1; // parse "ENTITY"
    const signed char Ws1              =  2; // white space read
    const signed char Name             =  3; // parse name
    const signed char Ws2              =  4; // white space read
    const signed char EValue           =  5; // parse entity value
    const signed char EValueR          =  6; // same as EValue, but already reported
    const signed char ExtID            =  7; // parse ExternalID
    const signed char Ws3              =  8; // white space read
    const signed char Ndata            =  9; // parse "NDATA"
    const signed char Ws4              = 10; // white space read
    const signed char NNam             = 11; // parse name
    const signed char NNamR            = 12; // same as NNam, but already reported
    const signed char PEDec            = 13; // parse PEDecl
    const signed char Ws6              = 14; // white space read
    const signed char PENam            = 15; // parse name
    const signed char Ws7              = 16; // white space read
    const signed char PEVal            = 17; // parse entity value
    const signed char PEValR           = 18; // same as PEVal, but already reported
    const signed char PEEID            = 19; // parse ExternalID
    const signed char PEEIDR           = 20; // same as PEEID, but already reported
    const signed char WsE              = 21; // white space read
    const signed char Done             = 22;
    const signed char EDDone           = 23; // done, but also report an external, unparsed entity decl

    const signed char InpWs            = 0; // white space
    const signed char InpPer           = 1; // %
    const signed char InpQuot          = 2; // " or '
    const signed char InpGt            = 3; // >
    const signed char InpN             = 4; // N
    const signed char InpUnknown       = 5;

    static const signed char table[22][6] = {
     /*  InpWs  InpPer  InpQuot  InpGt  InpN    InpUnknown */
        { -1,    -1,     -1,      -1,    Ent,    -1      }, // Init
        { Ws1,   -1,     -1,      -1,    -1,     -1      }, // Ent
        { -1,    PEDec,  -1,      -1,    Name,   Name    }, // Ws1
        { Ws2,   -1,     -1,      -1,    -1,     -1      }, // Name
        { -1,    -1,     EValue,  -1,    -1,     ExtID   }, // Ws2
        { WsE,   -1,     -1,      Done,  -1,     -1      }, // EValue
        { WsE,   -1,     -1,      Done,  -1,     -1      }, // EValueR
        { Ws3,   -1,     -1,      EDDone,-1,     -1      }, // ExtID
        { -1,    -1,     -1,      EDDone,Ndata,  -1      }, // Ws3
        { Ws4,   -1,     -1,      -1,    -1,     -1      }, // Ndata
        { -1,    -1,     -1,      -1,    NNam,   NNam    }, // Ws4
        { WsE,   -1,     -1,      Done,  -1,     -1      }, // NNam
        { WsE,   -1,     -1,      Done,  -1,     -1      }, // NNamR
        { Ws6,   -1,     -1,      -1,    -1,     -1      }, // PEDec
        { -1,    -1,     -1,      -1,    PENam,  PENam   }, // Ws6
        { Ws7,   -1,     -1,      -1,    -1,     -1      }, // PENam
        { -1,    -1,     PEVal,   -1,    -1,     PEEID   }, // Ws7
        { WsE,   -1,     -1,      Done,  -1,     -1      }, // PEVal
        { WsE,   -1,     -1,      Done,  -1,     -1      }, // PEValR
        { WsE,   -1,     -1,      Done,  -1,     -1      }, // PEEID
        { WsE,   -1,     -1,      Done,  -1,     -1      }, // PEEIDR
        { -1,    -1,     -1,      Done,  -1,     -1      }  // WsE
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseEntityDecl (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case EValue:
                if ( !entityExist(name())) {
                    QString errorMessage;
                    if (isExpandedEntityValueTooLarge(&errorMessage)) {
                        reportParseError(errorMessage);
                        return false;
                    }

                    entities.insert(name(), string());
                    if (declHnd) {
                        if (!declHnd->internalEntityDecl(name(), string())) {
                            reportParseError(declHnd->errorString());
                            return false;
                        }
                    }
                }
                state = EValueR;
                break;
            case NNam:
                if ( !entityExist(name())) {
                    externEntities.insert(name(), QXmlSimpleReaderPrivate::ExternEntity(publicId, systemId, ref()));
                    if (dtdHnd) {
                        if (!dtdHnd->unparsedEntityDecl(name(), publicId, systemId, ref())) {
                            reportParseError(declHnd->errorString());
                            return false;
                        }
                    }
                }
                state = NNamR;
                break;
            case PEVal:
                if ( !entityExist(name())) {
                    parameterEntities.insert(name(), string());
                    if (declHnd) {
                        if (!declHnd->internalEntityDecl(QLatin1Char('%') + name(), string())) {
                            reportParseError(declHnd->errorString());
                            return false;
                        }
                    }
                }
                state = PEValR;
                break;
            case PEEID:
                if ( !entityExist(name())) {
                    externParameterEntities.insert(name(), QXmlSimpleReaderPrivate::ExternParameterEntity(publicId, systemId));
                    if (declHnd) {
                        if (!declHnd->externalEntityDecl(QLatin1Char('%') + name(), publicId, systemId)) {
                            reportParseError(declHnd->errorString());
                            return false;
                        }
                    }
                }
                state = PEEIDR;
                break;
            case EDDone:
                if ( !entityExist(name())) {
                    externEntities.insert(name(), QXmlSimpleReaderPrivate::ExternEntity(publicId, systemId, QString()));
                    if (declHnd) {
                        if (!declHnd->externalEntityDecl(name(), publicId, systemId)) {
                            reportParseError(declHnd->errorString());
                            return false;
                        }
                    }
                }
                return true;
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('%')) {
            input = InpPer;
        } else if (c == QLatin1Char('"') || c == QLatin1Char('\'')) {
            input = InpQuot;
        } else if (c == QLatin1Char('>')) {
            input = InpGt;
        } else if (c == QLatin1Char('N')) {
            input = InpN;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Ent:
                parseString_s = QLatin1String("NTITY");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case Ws1:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case Name:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case Ws2:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case EValue:
            case EValueR:
                if (!parseEntityValue()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case ExtID:
                parseExternalID_allowPublicID = false;
                if (!parseExternalID()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case Ws3:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case Ndata:
                parseString_s = QLatin1String("NDATA");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case Ws4:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case NNam:
            case NNamR:
                parseName_useRef = true;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case PEDec:
                next();
                break;
            case Ws6:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case PENam:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case Ws7:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case PEVal:
            case PEValR:
                if (!parseEntityValue()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case PEEID:
            case PEEIDR:
                parseExternalID_allowPublicID = false;
                if (!parseExternalID()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case WsE:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
                    return false;
                }
                break;
            case EDDone:
                next();
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parseEntityValue()

bool QXmlSimpleReaderPrivate::parseEntityValue ( )

private

Definition at line 7318 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char Dq               = 1; // EntityValue is double quoted
    const signed char DqC              = 2; // signed character
    const signed char DqPER            = 3; // PERefence
    const signed char DqRef            = 4; // Reference
    const signed char Sq               = 5; // EntityValue is double quoted
    const signed char SqC              = 6; // signed character
    const signed char SqPER            = 7; // PERefence
    const signed char SqRef            = 8; // Reference
    const signed char Done             = 9;

    const signed char InpDq            = 0; // "
    const signed char InpSq            = 1; // '
    const signed char InpAmp           = 2; // &
    const signed char InpPer           = 3; // %
    const signed char InpUnknown       = 4;

    static const signed char table[9][5] = {
     /*  InpDq  InpSq  InpAmp  InpPer  InpUnknown */
        { Dq,    Sq,    -1,     -1,     -1    }, // Init
        { Done,  DqC,   DqRef,  DqPER,  DqC   }, // Dq
        { Done,  DqC,   DqRef,  DqPER,  DqC   }, // DqC
        { Done,  DqC,   DqRef,  DqPER,  DqC   }, // DqPER
        { Done,  DqC,   DqRef,  DqPER,  DqC   }, // DqRef
        { SqC,   Done,  SqRef,  SqPER,  SqC   }, // Sq
        { SqC,   Done,  SqRef,  SqPER,  SqC   }, // SqC
        { SqC,   Done,  SqRef,  SqPER,  SqC   }, // SqPER
        { SqC,   Done,  SqRef,  SqPER,  SqC   }  // SqRef
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseEntityValue (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseEntityValue, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseEntityValue, state);
            return false;
        }
        if        (c == QLatin1Char('"')) {
            input = InpDq;
        } else if (c == QLatin1Char('\'')) {
            input = InpSq;
        } else if (c == QLatin1Char('&')) {
            input = InpAmp;
        } else if (c == QLatin1Char('%')) {
            input = InpPer;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Dq:
            case Sq:
                stringClear();
                next();
                break;
            case DqC:
            case SqC:
                stringAddC();
                next();
                break;
            case DqPER:
            case SqPER:
                parsePEReference_context = InEntityValue;
                if (!parsePEReference()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityValue, state);
                    return false;
                }
                break;
            case DqRef:
            case SqRef:
                parseReference_context = InEntityValue;
                if (!parseReference()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityValue, state);
                    return false;
                }
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parseExternalID()

bool QXmlSimpleReaderPrivate::parseExternalID ( )

private

Definition at line 5373 of file qxml.cpp.

{
    const signed char Init             =  0;
    const signed char Sys              =  1; // parse 'SYSTEM'
    const signed char SysWS            =  2; // parse the whitespace after 'SYSTEM'
    const signed char SysSQ            =  3; // parse SystemLiteral with '
    const signed char SysSQ2           =  4; // parse SystemLiteral with '
    const signed char SysDQ            =  5; // parse SystemLiteral with "
    const signed char SysDQ2           =  6; // parse SystemLiteral with "
    const signed char Pub              =  7; // parse 'PUBLIC'
    const signed char PubWS            =  8; // parse the whitespace after 'PUBLIC'
    const signed char PubSQ            =  9; // parse PubidLiteral with '
    const signed char PubSQ2           = 10; // parse PubidLiteral with '
    const signed char PubDQ            = 11; // parse PubidLiteral with "
    const signed char PubDQ2           = 12; // parse PubidLiteral with "
    const signed char PubE             = 13; // finished parsing the PubidLiteral
    const signed char PubWS2           = 14; // parse the whitespace after the PubidLiteral
    const signed char PDone            = 15; // done if allowPublicID is true
    const signed char Done             = 16;

    const signed char InpSQ            = 0; // '
    const signed char InpDQ            = 1; // "
    const signed char InpS             = 2; // S
    const signed char InpP             = 3; // P
    const signed char InpWs            = 4; // white space
    const signed char InpUnknown       = 5;

    static const signed char table[15][6] = {
     /*  InpSQ    InpDQ    InpS     InpP     InpWs     InpUnknown */
        { -1,      -1,      Sys,     Pub,     -1,       -1      }, // Init
        { -1,      -1,      -1,      -1,      SysWS,    -1      }, // Sys
        { SysSQ,   SysDQ,   -1,      -1,      -1,       -1      }, // SysWS
        { Done,    SysSQ2,  SysSQ2,  SysSQ2,  SysSQ2,   SysSQ2  }, // SysSQ
        { Done,    SysSQ2,  SysSQ2,  SysSQ2,  SysSQ2,   SysSQ2  }, // SysSQ2
        { SysDQ2,  Done,    SysDQ2,  SysDQ2,  SysDQ2,   SysDQ2  }, // SysDQ
        { SysDQ2,  Done,    SysDQ2,  SysDQ2,  SysDQ2,   SysDQ2  }, // SysDQ2
        { -1,      -1,      -1,      -1,      PubWS,    -1      }, // Pub
        { PubSQ,   PubDQ,   -1,      -1,      -1,       -1      }, // PubWS
        { PubE,    -1,      PubSQ2,  PubSQ2,  PubSQ2,   PubSQ2  }, // PubSQ
        { PubE,    -1,      PubSQ2,  PubSQ2,  PubSQ2,   PubSQ2  }, // PubSQ2
        { -1,      PubE,    PubDQ2,  PubDQ2,  PubDQ2,   PubDQ2  }, // PubDQ
        { -1,      PubE,    PubDQ2,  PubDQ2,  PubDQ2,   PubDQ2  }, // PubDQ2
        { PDone,   PDone,   PDone,   PDone,   PubWS2,   PDone   }, // PubE
        { SysSQ,   SysDQ,   PDone,   PDone,   PDone,    PDone   }  // PubWS2
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        systemId.clear();
        publicId.clear();
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseExternalID (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case PDone:
                if (parseExternalID_allowPublicID) {
                    publicId = string();
                    return true;
                } else {
                    reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                    return false;
                }
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseExternalID, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('\'')) {
            input = InpSQ;
        } else if (c == QLatin1Char('"')) {
            input = InpDQ;
        } else if (c == QLatin1Char('S')) {
            input = InpS;
        } else if (c == QLatin1Char('P')) {
            input = InpP;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Sys:
                parseString_s = QLatin1String("SYSTEM");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
                    return false;
                }
                break;
            case SysWS:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
                    return false;
                }
                break;
            case SysSQ:
            case SysDQ:
                stringClear();
                next();
                break;
            case SysSQ2:
            case SysDQ2:
                stringAddC();
                next();
                break;
            case Pub:
                parseString_s = QLatin1String("PUBLIC");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
                    return false;
                }
                break;
            case PubWS:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
                    return false;
                }
                break;
            case PubSQ:
            case PubDQ:
                stringClear();
                next();
                break;
            case PubSQ2:
            case PubDQ2:
                stringAddC();
                next();
                break;
            case PubE:
                next();
                break;
            case PubWS2:
                publicId = string();
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
                    return false;
                }
                break;
            case Done:
                systemId = string();
                next();
                break;
        }
    }
    return false;
}

parseFailed()

void QXmlSimpleReaderPrivate::parseFailed ( ParseFunction  where, int  state  )

private

Definition at line 8459 of file qxml.cpp.

{
    if (parseStack!=0 && error.isNull()) {
        pushParseState(where, state);
    }
}

parseMarkupdecl()

bool QXmlSimpleReaderPrivate::parseMarkupdecl ( )

private

Definition at line 5551 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char Lt               = 1; // < was read
    const signed char Em               = 2; // ! was read
    const signed char CE               = 3; // E was read
    const signed char Qm               = 4; // ? was read
    const signed char Dash             = 5; // - was read
    const signed char CA               = 6; // A was read
    const signed char CEL              = 7; // EL was read
    const signed char CEN              = 8; // EN was read
    const signed char CN               = 9; // N was read
    const signed char Done             = 10;

    const signed char InpLt            = 0; // <
    const signed char InpQm            = 1; // ?
    const signed char InpEm            = 2; // !
    const signed char InpDash          = 3; // -
    const signed char InpA             = 4; // A
    const signed char InpE             = 5; // E
    const signed char InpL             = 6; // L
    const signed char InpN             = 7; // N
    const signed char InpUnknown       = 8;

    static const signed char table[4][9] = {
     /*  InpLt  InpQm  InpEm  InpDash  InpA   InpE   InpL   InpN   InpUnknown */
        { Lt,    -1,    -1,    -1,      -1,    -1,    -1,    -1,    -1     }, // Init
        { -1,    Qm,    Em,    -1,      -1,    -1,    -1,    -1,    -1     }, // Lt
        { -1,    -1,    -1,    Dash,    CA,    CE,    -1,    CN,    -1     }, // Em
        { -1,    -1,    -1,    -1,      -1,    -1,    CEL,   CEN,   -1     }  // CE
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseMarkupdecl (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Qm:
                if (contentHnd) {
                    if (!contentHnd->processingInstruction(name(),string())) {
                        reportParseError(contentHnd->errorString());
                        return false;
                    }
                }
                return true;
            case Dash:
                if (lexicalHnd) {
                    if (!lexicalHnd->comment(string())) {
                        reportParseError(lexicalHnd->errorString());
                        return false;
                    }
                }
                return true;
            case CA:
                return true;
            case CEL:
                return true;
            case CEN:
                return true;
            case CN:
                return true;
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
            return false;
        }
        if        (c == QLatin1Char('<')) {
            input = InpLt;
        } else if (c == QLatin1Char('?')) {
            input = InpQm;
        } else if (c == QLatin1Char('!')) {
            input = InpEm;
        } else if (c == QLatin1Char('-')) {
            input = InpDash;
        } else if (c == QLatin1Char('A')) {
            input = InpA;
        } else if (c == QLatin1Char('E')) {
            input = InpE;
        } else if (c == QLatin1Char('L')) {
            input = InpL;
        } else if (c == QLatin1Char('N')) {
            input = InpN;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Lt:
                next();
                break;
            case Em:
                next();
                break;
            case CE:
                next();
                break;
            case Qm:
                parsePI_xmldecl = false;
                if (!parsePI()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
                    return false;
                }
                break;
            case Dash:
                if (!parseComment()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
                    return false;
                }
                break;
            case CA:
                if (!parseAttlistDecl()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
                    return false;
                }
                break;
            case CEL:
                if (!parseElementDecl()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
                    return false;
                }
                break;
            case CEN:
                if (!parseEntityDecl()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
                    return false;
                }
                break;
            case CN:
                if (!parseNotationDecl()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
                    return false;
                }
                break;
        }
    }
    return false;
}

parseMisc()

bool QXmlSimpleReaderPrivate::parseMisc ( )

private

Definition at line 4804 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char Lt               = 1; // '<' was read
    const signed char Comment          = 2; // read comment
    const signed char eatWS            = 3; // eat whitespaces
    const signed char PInstr           = 4; // read PI
    const signed char Comment2         = 5; // read comment

    const signed char InpWs            = 0; // S
    const signed char InpLt            = 1; // <
    const signed char InpQm            = 2; // ?
    const signed char InpEm            = 3; // !
    const signed char InpUnknown       = 4;

    static const signed char table[3][5] = {
     /*  InpWs   InpLt  InpQm  InpEm     InpUnknown */
        { eatWS,  Lt,    -1,    -1,       -1        }, // Init
        { -1,     -1,    PInstr,Comment,  -1        }, // Lt
        { -1,     -1,    -1,    -1,       Comment2  }  // Comment
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseMisc (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case eatWS:
                return true;
            case PInstr:
                if (contentHnd) {
                    if (!contentHnd->processingInstruction(name(),string())) {
                        reportParseError(contentHnd->errorString());
                        return false;
                    }
                }
                return true;
            case Comment2:
                if (lexicalHnd) {
                    if (!lexicalHnd->comment(string())) {
                        reportParseError(lexicalHnd->errorString());
                        return false;
                    }
                }
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseMisc, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('<')) {
            input = InpLt;
        } else if (c == QLatin1Char('?')) {
            input = InpQm;
        } else if (c == QLatin1Char('!')) {
            input = InpEm;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case eatWS:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
                    return false;
                }
                break;
            case Lt:
                next();
                break;
            case PInstr:
                parsePI_xmldecl = false;
                if (!parsePI()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
                    return false;
                }
                break;
            case Comment:
                next();
                break;
            case Comment2:
                if (!parseComment()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
                    return false;
                }
                break;
        }
    }
    return false;
}

parseName()

bool QXmlSimpleReaderPrivate::parseName ( )

private

Definition at line 7667 of file qxml.cpp.

{
    const int Init             = 0;
    const int Name1            = 1; // parse first character of the name
    const int Name             = 2; // parse name
    const int Done             = 3;

    static const int table[3][3] = {
     /*  InpNameBe  InpNameCh  InpUnknown */
        { Name1,     -1,        -1    }, // Init
        { Name,      Name,      Done  }, // Name1
        { Name,      Name,      Done  }  // Name
    };
    int state;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseName (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseName, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseName, state);
            return false;
        }

        // we can safely do the (int) cast thanks to the Q_ASSERTs earlier in this function
        state = table[state][(int)fastDetermineNameChar(c)];

        switch (state) {
            case Name1:
                if (parseName_useRef) {
                    refClear();
                    refAddC();
                } else {
                    nameClear();
                    nameAddC();
                }
                next();
                break;
            case Name:
                if (parseName_useRef) {
                    refAddC();
                } else {
                    nameAddC();
                }
                next();
                break;
        }
    }
    return false;
}

parseNmtoken()

bool QXmlSimpleReaderPrivate::parseNmtoken ( )

private

Definition at line 7749 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char NameF            = 1;
    const signed char Name             = 2;
    const signed char Done             = 3;

    const signed char InpNameCh        = 0; // NameChar without InpNameBe
    const signed char InpUnknown       = 1;

    static const signed char table[3][2] = {
     /*  InpNameCh  InpUnknown */
        { NameF,     -1    }, // Init
        { Name,      Done  }, // NameF
        { Name,      Done  }  // Name
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseNmtoken (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseNmtoken, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseNmtoken, state);
            return false;
        }
        if (determineNameChar(c) == NotName) {
            input = InpUnknown;
        } else {
            input = InpNameCh;
        }
        state = table[state][input];

        switch (state) {
            case NameF:
                nameClear();
                nameAddC();
                next();
                break;
            case Name:
                nameAddC();
                next();
                break;
        }
    }
    return false;
}

parseNotationDecl()

bool QXmlSimpleReaderPrivate::parseNotationDecl ( )

private

Definition at line 6673 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char Not              = 1; // read NOTATION
    const signed char Ws1              = 2; // eat whitespaces
    const signed char Nam              = 3; // read Name
    const signed char Ws2              = 4; // eat whitespaces
    const signed char ExtID            = 5; // parse ExternalID
    const signed char ExtIDR           = 6; // same as ExtID, but already reported
    const signed char Ws3              = 7; // eat whitespaces
    const signed char Done             = 8;

    const signed char InpWs            = 0;
    const signed char InpGt            = 1; // >
    const signed char InpN             = 2; // N
    const signed char InpUnknown       = 3;

    static const signed char table[8][4] = {
     /*  InpWs   InpGt  InpN    InpUnknown */
        { -1,     -1,    Not,    -1     }, // Init
        { Ws1,    -1,    -1,     -1     }, // Not
        { -1,     -1,    Nam,    Nam    }, // Ws1
        { Ws2,    Done,  -1,     -1     }, // Nam
        { -1,     Done,  ExtID,  ExtID  }, // Ws2
        { Ws3,    Done,  -1,     -1     }, // ExtID
        { Ws3,    Done,  -1,     -1     }, // ExtIDR
        { -1,     Done,  -1,     -1     }  // Ws3
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseNotationDecl (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case ExtID:
                // call the handler
                if (dtdHnd) {
                    if (!dtdHnd->notationDecl(name(), publicId, systemId)) {
                        reportParseError(dtdHnd->errorString());
                        return false;
                    }
                }
                state = ExtIDR;
                break;
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('>')) {
            input = InpGt;
        } else if (c == QLatin1Char('N')) {
            input = InpN;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Not:
                parseString_s = QLatin1String("NOTATION");
                if (!parseString()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
                    return false;
                }
                break;
            case Ws1:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
                    return false;
                }
                break;
            case Nam:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
                    return false;
                }
                break;
            case Ws2:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
                    return false;
                }
                break;
            case ExtID:
            case ExtIDR:
                parseExternalID_allowPublicID = true;
                if (!parseExternalID()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
                    return false;
                }
                break;
            case Ws3:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
                    return false;
                }
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parsePEReference()

bool QXmlSimpleReaderPrivate::parsePEReference ( )

private

Definition at line 5721 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char Next             = 1;
    const signed char Name             = 2;
    const signed char NameR            = 3; // same as Name, but already reported
    const signed char Done             = 4;

    const signed char InpSemi          = 0; // ;
    const signed char InpPer           = 1; // %
    const signed char InpUnknown       = 2;

    static const signed char table[4][3] = {
     /*  InpSemi  InpPer  InpUnknown */
        { -1,      Next,   -1    }, // Init
        { -1,      -1,     Name  }, // Next
        { Done,    -1,     -1    }, // Name
        { Done,    -1,     -1    }  // NameR
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parsePEReference (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parsePEReference, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Name:
                {
                    bool skipIt = true;
                    QString xmlRefString;

                    QMap<QString,QString>::Iterator it;
                    it = parameterEntities.find(ref());
                    if (it != parameterEntities.end()) {
                        skipIt = false;
                        xmlRefString = *it;
                    } else if (entityRes) {
                        QMap<QString,QXmlSimpleReaderPrivate::ExternParameterEntity>::Iterator it2;
                        it2 = externParameterEntities.find(ref());
                        QXmlInputSource *ret = 0;
                        if (it2 != externParameterEntities.end()) {
                            if (!entityRes->resolveEntity((*it2).publicId, (*it2).systemId, ret)) {
                                delete ret;
                                reportParseError(entityRes->errorString());
                                return false;
                            }
                            if (ret) {
                                xmlRefString = ret->data();
                                delete ret;
                                if (!stripTextDecl(xmlRefString)) {
                                    reportParseError(QLatin1String(XMLERR_ERRORINTEXTDECL));
                                    return false;
                                }
                                skipIt = false;
                            }
                        }
                    }

                    if (skipIt) {
                        if (contentHnd) {
                            if (!contentHnd->skippedEntity(QLatin1Char('%') + ref())) {
                                reportParseError(contentHnd->errorString());
                                return false;
                            }
                        }
                    } else {
                        if (parsePEReference_context == InEntityValue) {
                            // Included in literal
                            if (!insertXmlRef(xmlRefString, ref(), true))
                                return false;
                        } else if (parsePEReference_context == InDTD) {
                            // Included as PE
                            if (!insertXmlRef(QLatin1Char(' ') + xmlRefString + QLatin1Char(' '), ref(), false))
                                return false;
                        }
                    }
                }
                state = NameR;
                break;
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parsePEReference, state);
            return false;
        }
        if        (c == QLatin1Char(';')) {
            input = InpSemi;
        } else if (c == QLatin1Char('%')) {
            input = InpPer;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case Next:
                next();
                break;
            case Name:
            case NameR:
                parseName_useRef = true;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parsePEReference, state);
                    return false;
                }
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parsePI()

bool QXmlSimpleReaderPrivate::parsePI ( )

private

Definition at line 4935 of file qxml.cpp.

{
    const signed char Init             =  0;
    const signed char QmI              =  1; // ? was read
    const signed char Name             =  2; // read Name
    const signed char XMLDecl          =  3; // read XMLDecl
    const signed char Ws1              =  4; // eat ws after "xml" of XMLDecl
    const signed char PInstr           =  5; // read PI
    const signed char Ws2              =  6; // eat ws after Name of PI
    const signed char Version          =  7; // read versionInfo
    const signed char Ws3              =  8; // eat ws after versionInfo
    const signed char EorSD            =  9; // read EDecl or SDDecl
    const signed char Ws4              = 10; // eat ws after EDecl or SDDecl
    const signed char SD               = 11; // read SDDecl
    const signed char Ws5              = 12; // eat ws after SDDecl
    const signed char ADone            = 13; // almost done
    const signed char Char             = 14; // Char was read
    const signed char Qm               = 15; // Qm was read
    const signed char Done             = 16; // finished reading content

    const signed char InpWs            = 0; // whitespace
    const signed char InpNameBe        = 1; // NameBeginning
    const signed char InpGt            = 2; // >
    const signed char InpQm            = 3; // ?
    const signed char InpUnknown       = 4;

    static const signed char table[16][5] = {
     /*  InpWs,  InpNameBe  InpGt  InpQm   InpUnknown  */
        { -1,     -1,        -1,    QmI,    -1     }, // Init
        { -1,     Name,      -1,    -1,     -1     }, // QmI
        { -1,     -1,        -1,    -1,     -1     }, // Name (this state is left not through input)
        { Ws1,    -1,        -1,    -1,     -1     }, // XMLDecl
        { -1,     Version,   -1,    -1,     -1     }, // Ws1
        { Ws2,    -1,        -1,    Qm,     -1     }, // PInstr
        { Char,   Char,      Char,  Qm,     Char   }, // Ws2
        { Ws3,    -1,        -1,    ADone,  -1     }, // Version
        { -1,     EorSD,     -1,    ADone,  -1     }, // Ws3
        { Ws4,    -1,        -1,    ADone,  -1     }, // EorSD
        { -1,     SD,        -1,    ADone,  -1     }, // Ws4
        { Ws5,    -1,        -1,    ADone,  -1     }, // SD
        { -1,     -1,        -1,    ADone,  -1     }, // Ws5
        { -1,     -1,        Done,  -1,     -1     }, // ADone
        { Char,   Char,      Char,  Qm,     Char   }, // Char
        { Char,   Char,      Done,  Qm,     Char   }, // Qm
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parsePI (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case Name:
                // test what name was read and determine the next state
                // (not very beautiful, I admit)
                if (name().toLower() == QLatin1String("xml")) {
                    if (parsePI_xmldecl && name() == QLatin1String("xml")) {
                        state = XMLDecl;
                    } else {
                        reportParseError(QLatin1String(XMLERR_INVALIDNAMEFORPI));
                        return false;
                    }
                } else {
                    state = PInstr;
                    stringClear();
                }
                break;
            case Version:
                // get version (syntax like an attribute)
                if (name() != QLatin1String("version")) {
                    reportParseError(QLatin1String(XMLERR_VERSIONEXPECTED));
                    return false;
                }
                xmlVersion = string();
                break;
            case EorSD:
                // get the EDecl or SDDecl (syntax like an attribute)
                if (name() == QLatin1String("standalone")) {
                    if (string()== QLatin1String("yes")) {
                        standalone = QXmlSimpleReaderPrivate::Yes;
                    } else if (string() == QLatin1String("no")) {
                        standalone = QXmlSimpleReaderPrivate::No;
                    } else {
                        reportParseError(QLatin1String(XMLERR_WRONGVALUEFORSDECL));
                        return false;
                    }
                } else if (name() == QLatin1String("encoding")) {
                    encoding = string();
                } else {
                    reportParseError(QLatin1String(XMLERR_EDECLORSDDECLEXPECTED));
                    return false;
                }
                break;
            case SD:
                if (name() != QLatin1String("standalone")) {
                    reportParseError(QLatin1String(XMLERR_SDDECLEXPECTED));
                    return false;
                }
                if (string() == QLatin1String("yes")) {
                    standalone = QXmlSimpleReaderPrivate::Yes;
                } else if (string() == QLatin1String("no")) {
                    standalone = QXmlSimpleReaderPrivate::No;
                } else {
                    reportParseError(QLatin1String(XMLERR_WRONGVALUEFORSDECL));
                    return false;
                }
                break;
            case Qm:
                // test if the skipping was legal
                if (!atEnd() && c != QLatin1Char('>'))
                    stringAddC(QLatin1Char('?'));
                break;
            case Done:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parsePI, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (determineNameChar(c) == NameBeginning) {
            input = InpNameBe;
        } else if (c == QLatin1Char('>')) {
            input = InpGt;
        } else if (c == QLatin1Char('?')) {
            input = InpQm;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case QmI:
                next();
                break;
            case Name:
                parseName_useRef = false;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
                    return false;
                }
                break;
            case Ws1:
            case Ws2:
            case Ws3:
            case Ws4:
            case Ws5:
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
                    return false;
                }
                break;
            case Version:
                if (!parseAttribute()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
                    return false;
                }
                break;
            case EorSD:
                if (!parseAttribute()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
                    return false;
                }
                break;
            case SD:
                // get the SDDecl (syntax like an attribute)
                if (standalone != QXmlSimpleReaderPrivate::Unknown) {
                    // already parsed the standalone declaration
                    reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
                    return false;
                }
                if (!parseAttribute()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
                    return false;
                }
                break;
            case ADone:
                next();
                break;
            case Char:
                stringAddC();
                next();
                break;
            case Qm:
                // skip the '?'
                next();
                break;
            case Done:
                next();
                break;
        }
    }
    return false;
}

parseProlog()

bool QXmlSimpleReaderPrivate::parseProlog ( )

private

Definition at line 3934 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char EatWS            = 1; // eat white spaces
    const signed char Lt               = 2; // '<' read
    const signed char Em               = 3; // '!' read
    const signed char DocType          = 4; // read doctype
    const signed char Comment          = 5; // read comment
    const signed char CommentR         = 6; // same as Comment, but already reported
    const signed char PInstr           = 7; // read PI
    const signed char PInstrR          = 8; // same as PInstr, but already reported
    const signed char Done             = 9;

    const signed char InpWs            = 0;
    const signed char InpLt            = 1; // <
    const signed char InpQm            = 2; // ?
    const signed char InpEm            = 3; // !
    const signed char InpD             = 4; // D
    const signed char InpDash          = 5; // -
    const signed char InpUnknown       = 6;

    static const signed char table[9][7] = {
     /*  InpWs   InpLt  InpQm  InpEm  InpD      InpDash  InpUnknown */
        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // Init
        { -1,     Lt,    -1,    -1,    -1,       -1,       -1      }, // EatWS
        { -1,     -1,    PInstr,Em,    Done,     -1,       Done    }, // Lt
        { -1,     -1,    -1,    -1,    DocType,  Comment,  -1      }, // Em
        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // DocType
        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // Comment
        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // CommentR
        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // PInstr
        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }  // PInstrR
    };
    signed char state;
    signed char input;

    if (parseStack == 0 || parseStack->isEmpty()) {
        xmldecl_possible = true;
        doctype_read = false;
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseProlog (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case DocType:
                if (doctype_read) {
                    reportParseError(QLatin1String(XMLERR_MORETHANONEDOCTYPE));
                    return false;
                } else {
                    doctype_read = false;
                }
                break;
            case Comment:
                if (lexicalHnd) {
                    if (!lexicalHnd->comment(string())) {
                        reportParseError(lexicalHnd->errorString());
                        return false;
                    }
                }
                state = CommentR;
                break;
            case PInstr:
                // call the handler
                if (contentHnd) {
                    if (xmldecl_possible && !xmlVersion.isEmpty()) {
                        QString value(QLatin1String("version='"));
                        value += xmlVersion;
                        value += QLatin1Char('\'');
                        if (!encoding.isEmpty()) {
                            value += QLatin1String(" encoding='");
                            value += encoding;
                            value += QLatin1Char('\'');
                        }
                        if (standalone == QXmlSimpleReaderPrivate::Yes) {
                            value += QLatin1String(" standalone='yes'");
                        } else if (standalone == QXmlSimpleReaderPrivate::No) {
                            value += QLatin1String(" standalone='no'");
                        }
                        if (!contentHnd->processingInstruction(QLatin1String("xml"), value)) {
                            reportParseError(contentHnd->errorString());
                            return false;
                        }
                    } else {
                        if (!contentHnd->processingInstruction(name(), string())) {
                            reportParseError(contentHnd->errorString());
                            return false;
                        }
                    }
                }
                // XML declaration only on first position possible
                xmldecl_possible = false;
                state = PInstrR;
                break;
            case Done:
                return true;
            case -1:
                reportParseError(QLatin1String(XMLERR_ERRORPARSINGELEMENT));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseProlog, state);
            return false;
        }
        if (is_S(c)) {
            input = InpWs;
        } else if (c == QLatin1Char('<')) {
            input = InpLt;
        } else if (c == QLatin1Char('?')) {
            input = InpQm;
        } else if (c == QLatin1Char('!')) {
            input = InpEm;
        } else if (c == QLatin1Char('D')) {
            input = InpD;
        } else if (c == QLatin1Char('-')) {
            input = InpDash;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case EatWS:
                // XML declaration only on first position possible
                xmldecl_possible = false;
                if (!eat_ws()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
                    return false;
                }
                break;
            case Lt:
                next();
                break;
            case Em:
                // XML declaration only on first position possible
                xmldecl_possible = false;
                next();
                break;
            case DocType:
                if (!parseDoctype()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
                    return false;
                }
                break;
            case Comment:
            case CommentR:
                if (!parseComment()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
                    return false;
                }
                break;
            case PInstr:
            case PInstrR:
                parsePI_xmldecl = xmldecl_possible;
                if (!parsePI()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
                    return false;
                }
                break;
        }
    }
    return false;
}

parseReference()

bool QXmlSimpleReaderPrivate::parseReference ( )

private

Definition at line 7837 of file qxml.cpp.

{
    // temporary variables (only used in very local context, so they don't
    // interfere with incremental parsing)
    uint tmp;
    bool ok;

    const signed char Init             =  0;
    const signed char SRef             =  1; // start of a reference
    const signed char ChRef            =  2; // parse CharRef
    const signed char ChDec            =  3; // parse CharRef decimal
    const signed char ChHexS           =  4; // start CharRef hexadecimal
    const signed char ChHex            =  5; // parse CharRef hexadecimal
    const signed char Name             =  6; // parse name
    const signed char DoneD            =  7; // done CharRef decimal
    const signed char DoneH            =  8; // done CharRef hexadecimal
    const signed char DoneN            =  9; // done EntityRef

    const signed char InpAmp           = 0; // &
    const signed char InpSemi          = 1; // ;
    const signed char InpHash          = 2; // #
    const signed char InpX             = 3; // x
    const signed char InpNum           = 4; // 0-9
    const signed char InpHex           = 5; // a-f A-F
    const signed char InpUnknown       = 6;

    static const signed char table[8][7] = {
     /*  InpAmp  InpSemi  InpHash  InpX     InpNum  InpHex  InpUnknown */
        { SRef,   -1,      -1,      -1,      -1,     -1,     -1    }, // Init
        { -1,     -1,      ChRef,   Name,    Name,   Name,   Name  }, // SRef
        { -1,     -1,      -1,      ChHexS,  ChDec,  -1,     -1    }, // ChRef
        { -1,     DoneD,   -1,      -1,      ChDec,  -1,     -1    }, // ChDec
        { -1,     -1,      -1,      -1,      ChHex,  ChHex,  -1    }, // ChHexS
        { -1,     DoneH,   -1,      -1,      ChHex,  ChHex,  -1    }, // ChHex
        { -1,     DoneN,   -1,      -1,      -1,     -1,     -1    }  // Name
    };
    signed char state;
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        parseReference_charDataRead = false;
        state = Init;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseReference (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseReference, state);
                return false;
            }
        }
    }

    for (;;) {
        switch (state) {
            case DoneD:
                return true;
            case DoneH:
                return true;
            case DoneN:
                return true;
            case -1:
                // Error
                reportParseError(QLatin1String(XMLERR_ERRORPARSINGREFERENCE));
                return false;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseReference, state);
            return false;
        }
        if        (c.row()) {
            input = InpUnknown;
        } else if (c.cell() == '&') {
            input = InpAmp;
        } else if (c.cell() == ';') {
            input = InpSemi;
        } else if (c.cell() == '#') {
            input = InpHash;
        } else if (c.cell() == 'x') {
            input = InpX;
        } else if ('0' <= c.cell() && c.cell() <= '9') {
            input = InpNum;
        } else if ('a' <= c.cell() && c.cell() <= 'f') {
            input = InpHex;
        } else if ('A' <= c.cell() && c.cell() <= 'F') {
            input = InpHex;
        } else {
            input = InpUnknown;
        }
        state = table[state][input];

        switch (state) {
            case SRef:
                refClear();
                next();
                break;
            case ChRef:
                next();
                break;
            case ChDec:
                refAddC();
                next();
                break;
            case ChHexS:
                next();
                break;
            case ChHex:
                refAddC();
                next();
                break;
            case Name:
                // read the name into the ref
                parseName_useRef = true;
                if (!parseName()) {
                    parseFailed(&QXmlSimpleReaderPrivate::parseReference, state);
                    return false;
                }
                break;
            case DoneD:
                tmp = ref().toUInt(&ok, 10);
                if (ok) {
                    stringAddC(QChar(tmp));
                } else {
                    reportParseError(QLatin1String(XMLERR_ERRORPARSINGREFERENCE));
                    return false;
                }
                parseReference_charDataRead = true;
                next();
                break;
            case DoneH:
                tmp = ref().toUInt(&ok, 16);
                if (ok) {
                    stringAddC(QChar(tmp));
                } else {
                    reportParseError(QLatin1String(XMLERR_ERRORPARSINGREFERENCE));
                    return false;
                }
                parseReference_charDataRead = true;
                next();
                break;
            case DoneN:
                if (!processReference())
                    return false;
                next();
                break;
        }
    }
    return false;
}

parseString()

bool QXmlSimpleReaderPrivate::parseString ( )

private

Definition at line 8207 of file qxml.cpp.

{
    const signed char InpCharExpected  = 0; // the character that was expected
    const signed char InpUnknown       = 1;

    signed char state; // state in this function is the position in the string s
    signed char input;

    if (parseStack==0 || parseStack->isEmpty()) {
        Done = parseString_s.length();
        state = 0;
    } else {
        state = parseStack->pop().state;
#if defined(QT_QXML_DEBUG)
        qDebug("QXmlSimpleReader: parseString (cont) in state %d", state);
#endif
        if (!parseStack->isEmpty()) {
            ParseFunction function = parseStack->top().function;
            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
                parseStack->pop();
#if defined(QT_QXML_DEBUG)
                qDebug("QXmlSimpleReader: eat_ws (cont)");
#endif
            }
            if (!(this->*function)()) {
                parseFailed(&QXmlSimpleReaderPrivate::parseString, state);
                return false;
            }
        }
    }

    for (;;) {
        if (state == Done) {
            return true;
        }

        if (atEnd()) {
            unexpectedEof(&QXmlSimpleReaderPrivate::parseString, state);
            return false;
        }
        if (c == parseString_s[(int)state]) {
            input = InpCharExpected;
        } else {
            input = InpUnknown;
        }
        if (input == InpCharExpected) {
            state++;
        } else {
            // Error
            reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
            return false;
        }

        next();
    }
    return false;
}

processElementAttribute()

bool QXmlSimpleReaderPrivate::processElementAttribute ( )

private

Definition at line 4410 of file qxml.cpp.

{
    QString uri, lname, prefix;
    const QString &name = QXmlSimpleReaderPrivate::name();
    const QString &string = QXmlSimpleReaderPrivate::string();

    // add the attribute to the list
    if (useNamespaces) {
        // is it a namespace declaration?
        namespaceSupport.splitName(name, prefix, lname);
        if (prefix == QLatin1String("xmlns")) {
            // namespace declaration
            namespaceSupport.setPrefix(lname, string);
            if (useNamespacePrefixes) {
                // according to http://www.w3.org/2000/xmlns/, the "prefix"
                // xmlns maps to the namespace name
                // http://www.w3.org/2000/xmlns/
                attList.append(name, QLatin1String("http://www.w3.org/2000/xmlns/"), lname, string);
            }
            // call the handler for prefix mapping
            if (contentHnd) {
                if (!contentHnd->startPrefixMapping(lname, string)) {
                    reportParseError(contentHnd->errorString());
                    return false;
                }
            }
        } else {
            // no namespace delcaration
            namespaceSupport.processName(name, true, uri, lname);
            attList.append(name, uri, lname, string);
        }
    } else {
        // no namespace support
        attList.append(name, uri, lname, string);
    }
    return true;
}

processElementEmptyTag()

bool QXmlSimpleReaderPrivate::processElementEmptyTag ( )

private

Definition at line 4308 of file qxml.cpp.

{
    QString uri, lname;
    // pop the stack and call the handler
    if (contentHnd) {
        if (useNamespaces) {
            // report startElement first...
            namespaceSupport.processName(tags.top(), false, uri, lname);
            if (!contentHnd->startElement(uri, lname, tags.top(), attList)) {
                reportParseError(contentHnd->errorString());
                return false;
            }
            // ... followed by endElement...
            if (!contentHnd->endElement(uri, lname, tags.pop())) {
                reportParseError(contentHnd->errorString());
                return false;
            }
            // ... followed by endPrefixMapping
            QStringList prefixesBefore, prefixesAfter;
            if (contentHnd) {
                prefixesBefore = namespaceSupport.prefixes();
            }
            namespaceSupport.popContext();
            // call the handler for prefix mapping
            prefixesAfter = namespaceSupport.prefixes();
            for (QStringList::Iterator it = prefixesBefore.begin(); it != prefixesBefore.end(); ++it) {
                if (!prefixesAfter.contains(*it)) {
                    if (!contentHnd->endPrefixMapping(*it)) {
                        reportParseError(contentHnd->errorString());
                        return false;
                    }
                }
            }
        } else {
            // report startElement first...
            if (!contentHnd->startElement(QString(), QString(), tags.top(), attList)) {
                reportParseError(contentHnd->errorString());
                return false;
            }
            // ... followed by endElement
            if (!contentHnd->endElement(QString(), QString(), tags.pop())) {
                reportParseError(contentHnd->errorString());
                return false;
            }
        }
    } else {
        tags.pop_back();
        namespaceSupport.popContext();
    }
    return true;
}

processElementETagBegin2()

bool QXmlSimpleReaderPrivate::processElementETagBegin2 ( )

private

Definition at line 4363 of file qxml.cpp.

{
    const QString &name = QXmlSimpleReaderPrivate::name();

    // pop the stack and compare it with the name
    if (tags.pop() != name) {
        reportParseError(QLatin1String(XMLERR_TAGMISMATCH));
        return false;
    }
    // call the handler
    if (contentHnd) {
        QString uri, lname;

        if (useNamespaces)
            namespaceSupport.processName(name, false, uri, lname);
        if (!contentHnd->endElement(uri, lname, name)) {
            reportParseError(contentHnd->errorString());
            return false;
        }
    }
    if (useNamespaces) {
        NamespaceMap prefixesBefore, prefixesAfter;
        if (contentHnd)
            prefixesBefore = namespaceSupport.d->ns;

        namespaceSupport.popContext();
        // call the handler for prefix mapping
        if (contentHnd) {
            prefixesAfter = namespaceSupport.d->ns;
            if (prefixesBefore.size() != prefixesAfter.size()) {
                for (NamespaceMap::const_iterator it = prefixesBefore.constBegin(); it != prefixesBefore.constEnd(); ++it) {
                    if (!it.key().isEmpty() && !prefixesAfter.contains(it.key())) {
                        if (!contentHnd->endPrefixMapping(it.key())) {
                            reportParseError(contentHnd->errorString());
                            return false;
                        }
                    }
                }
            }
        }
    }
    return true;
}

processReference()

bool QXmlSimpleReaderPrivate::processReference ( )

private

Definition at line 8000 of file qxml.cpp.

{
    QString reference = ref();
    if (reference == QLatin1String("amp")) {
        if (parseReference_context == InEntityValue) {
            // Bypassed
            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('a')); stringAddC(QLatin1Char('m')); stringAddC(QLatin1Char('p')); stringAddC(QLatin1Char(';'));
        } else {
            // Included or Included in literal
            stringAddC(QLatin1Char('&'));
        }
        parseReference_charDataRead = true;
    } else if (reference == QLatin1String("lt")) {
        if (parseReference_context == InEntityValue) {
            // Bypassed
            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('l')); stringAddC(QLatin1Char('t')); stringAddC(QLatin1Char(';'));
        } else {
            // Included or Included in literal
            stringAddC(QLatin1Char('<'));
        }
        parseReference_charDataRead = true;
    } else if (reference == QLatin1String("gt")) {
        if (parseReference_context == InEntityValue) {
            // Bypassed
            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('g')); stringAddC(QLatin1Char('t')); stringAddC(QLatin1Char(';'));
        } else {
            // Included or Included in literal
            stringAddC(QLatin1Char('>'));
        }
        parseReference_charDataRead = true;
    } else if (reference == QLatin1String("apos")) {
        if (parseReference_context == InEntityValue) {
            // Bypassed
            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('a')); stringAddC(QLatin1Char('p')); stringAddC(QLatin1Char('o')); stringAddC(QLatin1Char('s')); stringAddC(QLatin1Char(';'));
        } else {
            // Included or Included in literal
            stringAddC(QLatin1Char('\''));
        }
        parseReference_charDataRead = true;
    } else if (reference == QLatin1String("quot")) {
        if (parseReference_context == InEntityValue) {
            // Bypassed
            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('q')); stringAddC(QLatin1Char('u')); stringAddC(QLatin1Char('o')); stringAddC(QLatin1Char('t')); stringAddC(QLatin1Char(';'));
        } else {
            // Included or Included in literal
            stringAddC(QLatin1Char('"'));
        }
        parseReference_charDataRead = true;
    } else {
        QMap<QString,QString>::Iterator it;
        it = entities.find(reference);
        if (it != entities.end()) {
            // "Internal General"
            switch (parseReference_context) {
                case InContent:
                    // Included
                    if (!insertXmlRef(*it, reference, false))
                        return false;
                    parseReference_charDataRead = false;
                    break;
                case InAttributeValue:
                    // Included in literal
                    if (!insertXmlRef(*it, reference, true))
                        return false;
                    parseReference_charDataRead = false;
                    break;
                case InEntityValue:
                    {
                        // Bypassed
                        stringAddC(QLatin1Char('&'));
                        for (int i=0; i<(int)reference.length(); i++) {
                            stringAddC(reference[i]);
                        }
                        stringAddC(QLatin1Char(';'));
                        parseReference_charDataRead = true;
                    }
                    break;
                case InDTD:
                    // Forbidden
                    parseReference_charDataRead = false;
                    reportParseError(QLatin1String(XMLERR_INTERNALGENERALENTITYINDTD));
                    return false;
            }
        } else {
            QMap<QString,QXmlSimpleReaderPrivate::ExternEntity>::Iterator itExtern;
            itExtern = externEntities.find(reference);
            if (itExtern == externEntities.end()) {
                // entity not declared
                // ### check this case for conformance
                if (parseReference_context == InEntityValue) {
                    // Bypassed
                    stringAddC(QLatin1Char('&'));
                    for (int i=0; i<(int)reference.length(); i++) {
                        stringAddC(reference[i]);
                    }
                    stringAddC(QLatin1Char(';'));
                    parseReference_charDataRead = true;
                } else {
                    // if we have some char data read, report it now
                    if (parseReference_context == InContent) {
                        if (contentCharDataRead) {
                            if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
                                if (contentHnd != 0 && !contentHnd->characters(string())) {
                                    reportParseError(contentHnd->errorString());
                                    return false;
                                }
                            }
                            stringClear();
                            contentCharDataRead = false;
                        }
                    }

                    if (contentHnd) {
                        qt_xml_skipped_entity_in_content = parseReference_context == InContent;
                        if (!contentHnd->skippedEntity(reference)) {
                            qt_xml_skipped_entity_in_content = false;
                            reportParseError(contentHnd->errorString());
                            return false; // error
                        }
                        qt_xml_skipped_entity_in_content = false;
                    }
                }
            } else if ((*itExtern).notation.isNull()) {
                // "External Parsed General"
                switch (parseReference_context) {
                    case InContent:
                        {
                            // Included if validating
                            bool skipIt = true;
                            if (entityRes) {
                                QXmlInputSource *ret = 0;
                                if (!entityRes->resolveEntity((*itExtern).publicId, (*itExtern).systemId, ret)) {
                                    delete ret;
                                    reportParseError(entityRes->errorString());
                                    return false;
                                }
                                if (ret) {
                                    QString xmlRefString;
                                    QString buffer = ret->data();
                                    while (buffer.length()>0){
                                        xmlRefString += buffer;
                                        ret->fetchData();
                                        buffer = ret->data();
                                    }
                                    delete ret;
                                    if (!stripTextDecl(xmlRefString)) {
                                        reportParseError(QLatin1String(XMLERR_ERRORINTEXTDECL));
                                        return false;
                                    }
                                    if (!insertXmlRef(xmlRefString, reference, false))
                                        return false;
                                    skipIt = false;
                                }
                            }
                            if (skipIt && contentHnd) {
                                qt_xml_skipped_entity_in_content = true;
                                if (!contentHnd->skippedEntity(reference)) {
                                    qt_xml_skipped_entity_in_content = false;
                                    reportParseError(contentHnd->errorString());
                                    return false; // error
                                }
                                qt_xml_skipped_entity_in_content = false;
                            }
                            parseReference_charDataRead = false;
                        } break;
                    case InAttributeValue:
                        // Forbidden
                        parseReference_charDataRead = false;
                        reportParseError(QLatin1String(XMLERR_EXTERNALGENERALENTITYINAV));
                        return false;
                    case InEntityValue:
                        {
                            // Bypassed
                            stringAddC(QLatin1Char('&'));
                            for (int i=0; i<(int)reference.length(); i++) {
                                stringAddC(reference[i]);
                            }
                            stringAddC(QLatin1Char(';'));
                            parseReference_charDataRead = true;
                        }
                        break;
                    case InDTD:
                        // Forbidden
                        parseReference_charDataRead = false;
                        reportParseError(QLatin1String(XMLERR_EXTERNALGENERALENTITYINDTD));
                        return false;
                }
            } else {
                // "Unparsed"
                // ### notify for "Occurs as Attribute Value" missing (but this is no refence, anyway)
                // Forbidden
                parseReference_charDataRead = false;
                reportParseError(QLatin1String(XMLERR_UNPARSEDENTITYREFERENCE));
                return false; // error
            }
        }
    }
    return true; // no error
}

pushParseState()

void QXmlSimpleReaderPrivate::pushParseState ( ParseFunction  function, int  state  )

private

Definition at line 8473 of file qxml.cpp.

{
    QXmlSimpleReaderPrivate::ParseState ps;
    ps.function = function;
    ps.state = state;
    parseStack->push(ps);
}

ref()

const QString & QXmlSimpleReaderPrivate::ref ( )

private

Definition at line 8500 of file qxml.cpp.

{
    updateValue(refValue, refArray, refArrayPos, refValueLen);
    return refValue;
}

refAddC() [1/2]

void QXmlSimpleReaderPrivate::refAddC ( QChar  ch )

private

Definition at line 8518 of file qxml.cpp.

{
    if (refArrayPos == 256)
        updateValue(refValue, refArray, refArrayPos, refValueLen);
    refArray[refArrayPos++] = ch;
}

refAddC() [2/2]

void QXmlSimpleReaderPrivate::refAddC ( )

inlineprivate

Definition at line 449 of file qxml.cpp.

Referenced by refAddC().

{ refAddC(c); }

refClear()

void QXmlSimpleReaderPrivate::refClear ( )

inlineprivate

Definition at line 3024 of file qxml.cpp.

{
    refValueLen = 0; refArrayPos = 0;
}

reportEndEntities()

bool QXmlSimpleReaderPrivate::reportEndEntities ( )

private

Definition at line 4776 of file qxml.cpp.

{
    int count = (int)xmlRefStack.count();
    while (count != 0 && xmlRefStack.top().isEmpty()) {
        if (contentHnd) {
            if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
                if (!contentHnd->characters(string())) {
                    reportParseError(contentHnd->errorString());
                    return false;
                }
            }
        }
        stringClear();
        if (lexicalHnd) {
            if (!lexicalHnd->endEntity(xmlRefStack.top().name)) {
                reportParseError(lexicalHnd->errorString());
                return false;
            }
        }
        xmlRefStack.pop_back();
        count--;
    }
    return true;
}

reportParseError()

void QXmlSimpleReaderPrivate::reportParseError ( const QString &  error )

private

Definition at line 8417 of file qxml.cpp.

{
    this->error = error;
    if (errorHnd) {
        if (this->error.isNull()) {
            const QXmlParseException ex(QLatin1String(XMLERR_OK), columnNr+1, lineNr+1,
                                        thisPublicId, thisSystemId);
            errorHnd->fatalError(ex);
        } else {
            const QXmlParseException ex(this->error, columnNr+1, lineNr+1,
                                        thisPublicId, thisSystemId);
            errorHnd->fatalError(ex);
        }
    }
}

string()

const QString & QXmlSimpleReaderPrivate::string ( )

private

Definition at line 8490 of file qxml.cpp.

Referenced by processElementAttribute().

{
    updateValue(stringValue, stringArray, stringArrayPos, stringValueLen);
    return stringValue;
}

stringAddC() [1/2]

void QXmlSimpleReaderPrivate::stringAddC ( QChar  ch )

private

Definition at line 8506 of file qxml.cpp.

{
    if (stringArrayPos == 256)
        updateValue(stringValue, stringArray, stringArrayPos, stringValueLen);
    stringArray[stringArrayPos++] = ch;
}

stringAddC() [2/2]

void QXmlSimpleReaderPrivate::stringAddC ( )

inlineprivate

Definition at line 441 of file qxml.cpp.

Referenced by stringAddC().

{ stringAddC(c); }

stringClear()

void QXmlSimpleReaderPrivate::stringClear ( )

inlineprivate

Definition at line 3015 of file qxml.cpp.

{
    stringValueLen = 0; stringArrayPos = 0;
}

unexpectedEof()

void QXmlSimpleReaderPrivate::unexpectedEof ( ParseFunction  where, int  state  )

private

Definition at line 8439 of file qxml.cpp.

{
    if (parseStack == 0) {
        reportParseError(QLatin1String(XMLERR_UNEXPECTEDEOF));
    } else {
        if (c == QXmlInputSource::EndOfDocument) {
            reportParseError(QLatin1String(XMLERR_UNEXPECTEDEOF));
        } else {
            pushParseState(where, state);
        }
    }
}

Friends and Related Functions

QXmlSimpleReaderLocator

friend class QXmlSimpleReaderLocator

friend

Definition at line 511 of file qxml.cpp.

Properties

attDeclAName

QString QXmlSimpleReaderPrivate::attDeclAName

private

Definition at line 349 of file qxml.cpp.

attDeclEName

QString QXmlSimpleReaderPrivate::attDeclEName

private

Definition at line 348 of file qxml.cpp.

attList

QXmlAttributes QXmlSimpleReaderPrivate::attList

private

Definition at line 358 of file qxml.cpp.

c

QChar QXmlSimpleReaderPrivate::c

private

Definition at line 410 of file qxml.cpp.

columnNr

int QXmlSimpleReaderPrivate::columnNr

private

Definition at line 412 of file qxml.cpp.

Referenced by QXmlSimpleReaderLocator::columnNumber().

contentCharDataRead

bool QXmlSimpleReaderPrivate::contentCharDataRead

private

Definition at line 362 of file qxml.cpp.

contentHnd

QXmlContentHandler* QXmlSimpleReaderPrivate::contentHnd

private

Definition at line 401 of file qxml.cpp.

Referenced by QXmlSimpleReader::contentHandler().

declHnd

QXmlDeclHandler* QXmlSimpleReaderPrivate::declHnd

private

Definition at line 406 of file qxml.cpp.

Referenced by QXmlSimpleReader::declHandler().

doctype

QString QXmlSimpleReaderPrivate::doctype

private

Definition at line 332 of file qxml.cpp.

doctype_read

bool QXmlSimpleReaderPrivate::doctype_read

private

Definition at line 391 of file qxml.cpp.

Done

signed char QXmlSimpleReaderPrivate::Done

private

Definition at line 397 of file qxml.cpp.

dtdHnd

QXmlDTDHandler* QXmlSimpleReaderPrivate::dtdHnd

private

Definition at line 403 of file qxml.cpp.

Referenced by QXmlSimpleReader::DTDHandler().

dtdRecursionLimit

const int QXmlSimpleReaderPrivate::dtdRecursionLimit = 2

staticprivate

Definition at line 434 of file qxml.cpp.

emptyStr

QString QXmlSimpleReaderPrivate::emptyStr

private

Definition at line 426 of file qxml.cpp.

encoding

QString QXmlSimpleReaderPrivate::encoding

private

Definition at line 334 of file qxml.cpp.

entities

QMap<QString,QString> QXmlSimpleReaderPrivate::entities

private

Definition at line 313 of file qxml.cpp.

entityCharacterLimit

const int QXmlSimpleReaderPrivate::entityCharacterLimit = 1024

staticprivate

Definition at line 436 of file qxml.cpp.

entityRes

QXmlEntityResolver* QXmlSimpleReaderPrivate::entityRes

private

Definition at line 404 of file qxml.cpp.

Referenced by QXmlSimpleReader::entityResolver().

error

QString QXmlSimpleReaderPrivate::error

private

Definition at line 369 of file qxml.cpp.

errorHnd

QXmlErrorHandler* QXmlSimpleReaderPrivate::errorHnd

private

Definition at line 402 of file qxml.cpp.

Referenced by QXmlSimpleReader::errorHandler().

expandedSizes

QHash<QString, int> QXmlSimpleReaderPrivate::expandedSizes

private

Definition at line 431 of file qxml.cpp.

externEntities

QMap<QString,ExternEntity> QXmlSimpleReaderPrivate::externEntities

private

Definition at line 312 of file qxml.cpp.

externParameterEntities

QMap<QString,ExternParameterEntity> QXmlSimpleReaderPrivate::externParameterEntities

private

Definition at line 310 of file qxml.cpp.

inputSource

QXmlInputSource* QXmlSimpleReaderPrivate::inputSource

private

Definition at line 408 of file qxml.cpp.

lexicalHnd

QXmlLexicalHandler* QXmlSimpleReaderPrivate::lexicalHnd

private

Definition at line 405 of file qxml.cpp.

Referenced by QXmlSimpleReader::lexicalHandler().

lineNr

int QXmlSimpleReaderPrivate::lineNr

private

Definition at line 411 of file qxml.cpp.

Referenced by QXmlSimpleReaderLocator::lineNumber().

literalEntitySizes

QHash<QString, int> QXmlSimpleReaderPrivate::literalEntitySizes

private

Definition at line 428 of file qxml.cpp.

locator

QScopedPointer<QXmlLocator> QXmlSimpleReaderPrivate::locator

private

Definition at line 365 of file qxml.cpp.

nameArray

QChar QXmlSimpleReaderPrivate::nameArray[256]

private

Definition at line 414 of file qxml.cpp.

nameArrayPos

int QXmlSimpleReaderPrivate::nameArrayPos

private

Definition at line 416 of file qxml.cpp.

namespaceSupport

QXmlNamespaceSupport QXmlSimpleReaderPrivate::namespaceSupport

private

Definition at line 366 of file qxml.cpp.

nameValue

QString QXmlSimpleReaderPrivate::nameValue

private

Definition at line 415 of file qxml.cpp.

nameValueLen

int QXmlSimpleReaderPrivate::nameValueLen

private

Definition at line 417 of file qxml.cpp.

parameterEntities

QMap<QString,QString> QXmlSimpleReaderPrivate::parameterEntities

private

Definition at line 311 of file qxml.cpp.

parseExternalID_allowPublicID

bool QXmlSimpleReaderPrivate::parseExternalID_allowPublicID

private

Definition at line 377 of file qxml.cpp.

parseName_useRef

bool QXmlSimpleReaderPrivate::parseName_useRef

private

Definition at line 374 of file qxml.cpp.

parsePEReference_context

EntityRecognitionContext QXmlSimpleReaderPrivate::parsePEReference_context

private

Definition at line 378 of file qxml.cpp.

parsePI_xmldecl

bool QXmlSimpleReaderPrivate::parsePI_xmldecl

private

Definition at line 373 of file qxml.cpp.

parseReference_charDataRead

bool QXmlSimpleReaderPrivate::parseReference_charDataRead

private

Definition at line 375 of file qxml.cpp.

parseReference_context

EntityRecognitionContext QXmlSimpleReaderPrivate::parseReference_context

private

Definition at line 376 of file qxml.cpp.

parseStack

QStack<ParseState>* QXmlSimpleReaderPrivate::parseStack

private

Definition at line 387 of file qxml.cpp.

parseString_s

QString QXmlSimpleReaderPrivate::parseString_s

private

Definition at line 379 of file qxml.cpp.

publicId

QString QXmlSimpleReaderPrivate::publicId

private

Definition at line 337 of file qxml.cpp.

q_ptr

QXmlSimpleReader* QXmlSimpleReaderPrivate::q_ptr

private

Definition at line 509 of file qxml.cpp.

refArray

QChar QXmlSimpleReaderPrivate::refArray[256]

private

Definition at line 418 of file qxml.cpp.

refArrayPos

int QXmlSimpleReaderPrivate::refArrayPos

private

Definition at line 420 of file qxml.cpp.

referencesToOtherEntities

QHash<QString, QHash<QString, int> > QXmlSimpleReaderPrivate::referencesToOtherEntities

private

Definition at line 430 of file qxml.cpp.

refValue

QString QXmlSimpleReaderPrivate::refValue

private

Definition at line 419 of file qxml.cpp.

refValueLen

int QXmlSimpleReaderPrivate::refValueLen

private

Definition at line 421 of file qxml.cpp.

reportEntities

bool QXmlSimpleReaderPrivate::reportEntities

private

Definition at line 355 of file qxml.cpp.

Referenced by QXmlSimpleReader::feature().

reportWhitespaceCharData

bool QXmlSimpleReaderPrivate::reportWhitespaceCharData

private

Definition at line 354 of file qxml.cpp.

Referenced by QXmlSimpleReader::feature().

standalone

Standalone QXmlSimpleReaderPrivate::standalone

private

Definition at line 335 of file qxml.cpp.

startDTDwasReported

bool QXmlSimpleReaderPrivate::startDTDwasReported

private

Definition at line 394 of file qxml.cpp.

stringArray

QChar QXmlSimpleReaderPrivate::stringArray[256]

private

Definition at line 422 of file qxml.cpp.

stringArrayPos

int QXmlSimpleReaderPrivate::stringArrayPos

private

Definition at line 424 of file qxml.cpp.

stringValue

QString QXmlSimpleReaderPrivate::stringValue

private

Definition at line 423 of file qxml.cpp.

stringValueLen

int QXmlSimpleReaderPrivate::stringValueLen

private

Definition at line 425 of file qxml.cpp.

systemId

QString QXmlSimpleReaderPrivate::systemId

private

Definition at line 338 of file qxml.cpp.

tags

QStack<QString> QXmlSimpleReaderPrivate::tags

private

Definition at line 284 of file qxml.cpp.

thisPublicId

QString QXmlSimpleReaderPrivate::thisPublicId

private

Definition at line 345 of file qxml.cpp.

thisSystemId

QString QXmlSimpleReaderPrivate::thisSystemId

private

Definition at line 346 of file qxml.cpp.

useNamespacePrefixes

bool QXmlSimpleReaderPrivate::useNamespacePrefixes

private

Definition at line 353 of file qxml.cpp.

Referenced by QXmlSimpleReader::feature().

useNamespaces

bool QXmlSimpleReaderPrivate::useNamespaces

private

Definition at line 352 of file qxml.cpp.

Referenced by QXmlSimpleReader::feature().

xmldecl_possible

bool QXmlSimpleReaderPrivate::xmldecl_possible

private

Definition at line 390 of file qxml.cpp.

xmlRefStack

QStack<XmlRef> QXmlSimpleReaderPrivate::xmlRefStack

private

Definition at line 327 of file qxml.cpp.

xmlVersion

QString QXmlSimpleReaderPrivate::xmlVersion

private

Definition at line 333 of file qxml.cpp.

---

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

• /src/xml/sax/qxml.cpp