QXmlSimpleReader Class Reference

The QXmlSimpleReader class provides an implementation of a simple XML reader (i.e. parser). More...

#include <qxml.h>

Inheritance diagram for QXmlSimpleReader:

Public Member Functions
	QXmlSimpleReader ()
virtual	~QXmlSimpleReader ()
bool	feature (const QString &name, bool *ok=0) const
void	setFeature (const QString &name, bool value)
bool	hasFeature (const QString &name) const
void *	property (const QString &name, bool *ok=0) const
void	setProperty (const QString &name, void *value)
bool	hasProperty (const QString &name) const
void	setEntityResolver (QXmlEntityResolver *handler)
QXmlEntityResolver *	entityResolver () const
void	setDTDHandler (QXmlDTDHandler *handler)
QXmlDTDHandler *	DTDHandler () const
void	setContentHandler (QXmlContentHandler *handler)
QXmlContentHandler *	contentHandler () const
void	setErrorHandler (QXmlErrorHandler *handler)
QXmlErrorHandler *	errorHandler () const
void	setLexicalHandler (QXmlLexicalHandler *handler)
QXmlLexicalHandler *	lexicalHandler () const
void	setDeclHandler (QXmlDeclHandler *handler)
QXmlDeclHandler *	declHandler () const
bool	parse (const QXmlInputSource &input)
Public Member Functions inherited from QXmlReader
virtual	~QXmlReader ()

Private Types
enum	EntityRecognitionContext { InContent, InAttributeValue, InEntityValue, InDTD }

Private Member Functions
virtual bool	is_S (const QChar &)
virtual bool	is_Letter (const QChar &)
virtual bool	is_NameBeginning (const QChar &)
virtual bool	is_Digit (const QChar &)
virtual bool	is_CombiningChar (const QChar &)
virtual bool	is_Extender (const QChar &)
virtual bool	is_NameChar (const QChar &)
QString &	string ()
void	stringClear ()
void	stringAddC ()
void	stringAddC (const QChar &)
QString &	name ()
void	nameClear ()
void	nameAddC ()
void	nameAddC (const QChar &)
QString &	ref ()
void	refClear ()
void	refAddC ()
void	refAddC (const QChar &)
void	eat_ws ()
void	next_eat_ws ()
void	next ()
bool	atEnd ()
void	init (const QXmlInputSource &i)
bool	entityExist (const QString &) const
bool	parseProlog ()
bool	parseElement ()
bool	parseElementEmptyTag (bool &t, QString &uri, QString &lname)
bool	parseElementETagBegin2 (QString &uri, QString &lname)
bool	parseElementAttribute (QString &prefix, QString &uri, QString &lname)
bool	parseMisc ()
bool	parseContent ()
bool	parsePI (bool xmldecl=FALSE)
bool	parseDoctype ()
bool	parseComment ()
bool	parseName (bool useRef=FALSE)
bool	parseNmtoken ()
bool	parseAttribute ()
bool	parseReference (bool &charDataRead, EntityRecognitionContext context)
bool	processReference (bool &charDataRead, EntityRecognitionContext context)
bool	parseExternalID (bool allowPublicID=FALSE)
bool	parsePEReference (EntityRecognitionContext context)
bool	parseMarkupdecl ()
bool	parseAttlistDecl ()
bool	parseAttType ()
bool	parseAttValue ()
bool	parseElementDecl ()
bool	parseNotationDecl ()
bool	parseChoiceSeq ()
bool	parseEntityDecl ()
bool	parseEntityValue ()
bool	parseString (const QString &s)
void	reportParseError ()

Private Attributes
QXmlContentHandler *	contentHnd
QXmlErrorHandler *	errorHnd
QXmlDTDHandler *	dtdHnd
QXmlEntityResolver *	entityRes
QXmlLexicalHandler *	lexicalHnd
QXmlDeclHandler *	declHnd
QChar	c
int	lineNr
int	columnNr
int	pos
int	namePos
QChar	nameArray [256]
QString	nameValue
int	refPos
QChar	refArray [256]
QString	refValue
int	stringPos
QChar	stringArray [256]
QString	stringValue
QString	xml
int	xmlLength
QString	xmlRef
QValueStack< QString >	tags
QXmlSimpleReaderPrivate *	d

Static Private Attributes
static const QChar	QEOF = QChar((ushort)0xffff)

Friends
class	QXmlSimpleReaderPrivate
class	QXmlLocator

Detailed Description

The QXmlSimpleReader class provides an implementation of a simple XML reader (i.e. parser).

XML

This XML reader is sufficient for simple parsing tasks. Here is a short list of the properties of this reader:

• well-formed parser
• does not parse any external entities
• can do namespace processing

For getting started see also the Quick start.

Definition at line 238 of file qxml.h.

Member Enumeration Documentation

enum QXmlSimpleReader::EntityRecognitionContext

private

Enumerator
InContent
InAttributeValue
InEntityValue
InDTD

Definition at line 324 of file qxml.h.

{ InContent, InAttributeValue, InEntityValue, InDTD };

Constructor & Destructor Documentation

QXmlSimpleReader::QXmlSimpleReader

(

)

Constructs a simple XML reader.

Definition at line 1904 of file qxml.cpp.

{
    d = new QXmlSimpleReaderPrivate();
    d->locator = new QXmlLocator( this );

    entityRes  = 0;
    dtdHnd     = 0;
    contentHnd = 0;
    errorHnd   = 0;
    lexicalHnd = 0;
    declHnd    = 0;

    // default feature settings
    d->useNamespaces = TRUE;
    d->useNamespacePrefixes = FALSE;
    d->reportWhitespaceCharData = TRUE;
}

QXmlSimpleReader::~QXmlSimpleReader ( )

virtual

Destroys a simple XML reader.

Definition at line 1925 of file qxml.cpp.

{
    delete d->locator;
    delete d;
}

Member Function Documentation

bool QXmlSimpleReader::atEnd ( )

inlineprivate

Definition at line 575 of file qxml.h.

{ return c == QEOF; }

QXmlContentHandler * QXmlSimpleReader::contentHandler ( ) const

virtual

Implements QXmlReader.

Definition at line 2047 of file qxml.cpp.

{ return contentHnd; }

QXmlDeclHandler * QXmlSimpleReader::declHandler ( ) const

virtual

Implements QXmlReader.

Definition at line 2071 of file qxml.cpp.

{ return declHnd; }

QXmlDTDHandler * QXmlSimpleReader::DTDHandler ( ) const

virtual

Implements QXmlReader.

Definition at line 2039 of file qxml.cpp.

{ return dtdHnd; }

void QXmlSimpleReader::eat_ws ( )

inlineprivate

Definition at line 578 of file qxml.h.

{ while ( !atEnd() && is_S(c) ) next(); }

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

private

Returns TRUE if a entity with the name e exists, otherwise returns FALSE.

Definition at line 6045 of file qxml.cpp.

{
    if (  d->parameterEntities.find(e) == d->parameterEntities.end() &&
            d->externParameterEntities.find(e) == d->externParameterEntities.end() ) {
        return FALSE;
    } else {
        return TRUE;
    }
}

QXmlEntityResolver * QXmlSimpleReader::entityResolver ( ) const

virtual

Implements QXmlReader.

Definition at line 2031 of file qxml.cpp.

{ return entityRes; }

QXmlErrorHandler * QXmlSimpleReader::errorHandler ( ) const

virtual

Implements QXmlReader.

Definition at line 2055 of file qxml.cpp.

{ return errorHnd; }

bool QXmlSimpleReader::feature ( const QString &  name, bool *  ok = 0  ) const

virtual

Gets the state of a feature.

See also

setFeature() hasFeature()

Implements QXmlReader.

Definition at line 1936 of file qxml.cpp.

{
    if ( ok != 0 )
        *ok = TRUE;
    if        ( name == "http://xml.org/sax/features/namespaces" ) {
        return d->useNamespaces;
    } else if ( name == "http://xml.org/sax/features/namespace-prefixes" ) {
        return d->useNamespacePrefixes;
    } else if ( name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" ) {
        return d->reportWhitespaceCharData;
    } else {
        qWarning( "Unknown feature %s", name.ascii() );
        if ( ok != 0 )
            *ok = FALSE;
    }
    return FALSE;
}

bool QXmlSimpleReader::hasFeature ( const QString &  name ) const

virtual

Returns TRUE if the class has a feature named feature, otherwise FALSE.

See also

setFeature() feature()

Implements QXmlReader.

Definition at line 1990 of file qxml.cpp.

{
    if (    name == "http://xml.org/sax/features/namespaces" ||
            name == "http://xml.org/sax/features/namespace-prefixes" ||
            name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" ) {
        return TRUE;
    } else {
        return FALSE;
    }
}

bool QXmlSimpleReader::hasProperty ( const QString &  name ) const

virtual

Returns FALSE since this class does not support any properties.

Implements QXmlReader.

Definition at line 2021 of file qxml.cpp.

{
    return FALSE;
}

void QXmlSimpleReader::init ( const QXmlInputSource &  i )

private

Inits the data values.

Definition at line 6016 of file qxml.cpp.

{
    xml = i.data();
    xmlLength = xml.length();
    xmlRef = "";

    d->externParameterEntities.clear();
    d->parameterEntities.clear();
    d->externEntities.clear();
    d->entities.clear();

    tags.clear();

    d->doctype = "";
    d->xmlVersion = "";
    d->encoding = "";
    d->standalone = QXmlSimpleReaderPrivate::Unknown;

    lineNr = 0;
    columnNr = -1;
    pos = 0;
    next();
    d->error = XMLERR_OK;
}

bool QXmlSimpleReader::is_CombiningChar ( const QChar &  )

inlineprivatevirtual

Definition at line 542 of file qxml.h.

{ return FALSE; }

bool QXmlSimpleReader::is_Digit ( const QChar &  ch )

inlineprivatevirtual

Definition at line 539 of file qxml.h.

{ return ch.isDigit(); }

bool QXmlSimpleReader::is_Extender ( const QChar &  )

inlineprivatevirtual

Definition at line 545 of file qxml.h.

{ return FALSE; }

bool QXmlSimpleReader::is_Letter ( const QChar &  ch )

inlineprivatevirtual

Definition at line 533 of file qxml.h.

{ return ch.isLetter(); }

bool QXmlSimpleReader::is_NameBeginning ( const QChar &  ch )

inlineprivatevirtual

Definition at line 536 of file qxml.h.

{ return ch=='_' || ch==':' || ch.isLetter(); }

bool QXmlSimpleReader::is_NameChar ( const QChar &  ch )

inlineprivatevirtual

Definition at line 548 of file qxml.h.

{
    return ch=='.' || ch=='-' || ch=='_' || ch==':' ||
        is_Letter(ch) || is_Digit(ch) ||
        is_CombiningChar(ch) || is_Extender(ch);
}

bool QXmlSimpleReader::is_S ( const QChar &  ch )

inlineprivatevirtual

Definition at line 530 of file qxml.h.

{ return ch==' ' || ch=='\t' || ch=='\n' || ch=='\r'; }

QXmlLexicalHandler * QXmlSimpleReader::lexicalHandler ( ) const

virtual

Implements QXmlReader.

Definition at line 2063 of file qxml.cpp.

{ return lexicalHnd; }

QString & QXmlSimpleReader::name ( )

inlineprivate

Definition at line 592 of file qxml.h.

{
    nameValue += QString( nameArray, namePos );
    namePos = 0;
    return nameValue;
}

void QXmlSimpleReader::nameAddC ( )

inlineprivate

Definition at line 620 of file qxml.h.

{
    if ( namePos >= 256 ) {
        nameValue += QString( nameArray, namePos );
        namePos = 0;
    }
    nameArray[namePos++] = c;
}

void QXmlSimpleReader::nameAddC ( const QChar &  ch )

inlineprivate

Definition at line 645 of file qxml.h.

{
    if ( namePos >= 256 ) {
        nameValue += QString( nameArray, namePos );
        namePos = 0;
    }
    nameArray[namePos++] = ch;
}

void QXmlSimpleReader::nameClear ( )

inlineprivate

Definition at line 607 of file qxml.h.

{ nameValue = ""; namePos = 0; }

void QXmlSimpleReader::next ( )

inlineprivate

Definition at line 555 of file qxml.h.

{
    if ( !xmlRef.isEmpty() ) {
        c = xmlRef[0];
        xmlRef.remove( 0, 1 );
    } else {
        if ( c=='\n' || c=='\r' ) {
            lineNr++;
            columnNr = -1;
        }
        if ( pos >= xmlLength ) {
            c = QEOF;
        } else {
            c = xml[pos];
            columnNr++;
            pos++;
        }
    }
}

void QXmlSimpleReader::next_eat_ws ( )

inlineprivate

Definition at line 581 of file qxml.h.

{ next(); eat_ws(); }

bool QXmlSimpleReader::parse ( const QXmlInputSource &  input )

virtual

Implements QXmlReader.

Definition at line 2077 of file qxml.cpp.

{
    init( input );
    // call the handler
    if ( contentHnd ) {
        contentHnd->setDocumentLocator( d->locator );
        if ( !contentHnd->startDocument() ) {
            d->error = contentHnd->errorString();
            goto parseError;
        }
    }
    // parse prolog
    if ( !parseProlog() ) {
        d->error = XMLERR_ERRORPARSINGPROLOG;
        goto parseError;
    }
    // parse element
    if ( !parseElement() ) {
        d->error = XMLERR_ERRORPARSINGMAINELEMENT;
        goto parseError;
    }
    // parse Misc*
    while ( !atEnd() ) {
        if ( !parseMisc() ) {
            d->error = XMLERR_ERRORPARSINGMISC;
            goto parseError;
        }
    }
    // is stack empty?
    if ( !tags.isEmpty() ) {
        d->error = XMLERR_UNEXPECTEDEOF;
        goto parseError;
    }
    // call the handler
    if ( contentHnd ) {
        if ( !contentHnd->endDocument() ) {
            d->error = contentHnd->errorString();
            goto parseError;
        }
    }

    return TRUE;

    // error handling

parseError:
    reportParseError();
    tags.clear();
    return FALSE;
}

bool QXmlSimpleReader::parseAttlistDecl ( )

private

Parse a AttlistDecl [52].

Precondition: the beginning '<!' is already read and the head stands on the 'A' of '<!ATTLIST'

Definition at line 3880 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;

    // use some kind of state machine for parsing
    static 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == '>' ) {
            input = InpGt;
        } else if ( c == '#' ) {
            input = InpHash;
        } else if ( c == 'A' ) {
            input = InpA;
        } else if ( c == 'I' ) {
            input = InpI;
        } else if ( c == 'F' ) {
            input = InpF;
        } else if ( c == 'R' ) {
            input = InpR;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Attlist:
                parseOk = parseString( "ATTLIST" );
                break;
            case Ws:
            case Ws1:
            case Ws2:
            case Ws3:
                eat_ws();
                break;
            case Name:
                parseOk = parseName();
                break;
            case Attdef:
                parseOk = parseName();
                break;
            case Atttype:
                parseOk = parseAttType();
                break;
            case DDecH:
                next();
                break;
            case DefReq:
                parseOk = parseString( "REQUIRED" );
                break;
            case DefImp:
                parseOk = parseString( "IMPLIED" );
                break;
            case DefFix:
                parseOk = parseString( "FIXED" );
                break;
            case Attval:
                parseOk = parseAttValue();
                break;
            case Ws4:
                if ( declHnd ) {
                    // TODO: not all values are computed yet...
                    if ( !declHnd->attributeDecl( d->attDeclEName, d->attDeclAName, "", "", "" ) ) {
                        d->error = declHnd->errorString();
                        goto parseError;
                    }
                }
                eat_ws();
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Attlist:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case Name:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                d->attDeclEName = name();
                break;
            case Attdef:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                d->attDeclAName = name();
                break;
            case Atttype:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGATTTYPE;
                    goto parseError;
                }
                break;
            case DefReq:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case DefImp:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case DefFix:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case Attval:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGATTVALUE;
                    goto parseError;
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_LETTEREXPECTED;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseAttribute ( )

private

Parse a Attribute [41].

Precondition: the head stands on the first character of the name of the attribute (i.e. all whitespaces are already parsed).

The head stand on the next character after the end quotes. The variable name contains the name of the attribute and the variable string contains the value of the attribute.

Definition at line 5402 of file qxml.cpp.

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

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

    // use some kind of state machine for parsing
    static signed char 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
    };
    signed char state = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_NameBeginning(c) ) {
            input = InpNameBe;
        } else if ( c == '=' ) {
            input = InpEq;
        } else if ( c == '"' ) {
            input = InpDq;
        } else if ( c == '\'' ) {
            input = InpSq;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case PName:
                parseOk = parseName();
                break;
            case Ws:
                eat_ws();
                break;
            case Eq:
                next_eat_ws();
                break;
            case Quotes:
                parseOk = parseAttValue();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case PName:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                break;
            case Quotes:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGATTVALUE;
                    goto parseError;
                }
                // Done
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_UNEXPECTEDCHARACTER;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseAttType ( )

private

Parse a AttType [54]

Definition at line 4080 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;

    // use some kind of state machine for parsing
    static 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == '(' ) {
            input = InpOp;
        } else if ( c == ')' ) {
            input = InpCp;
        } else if ( c == '|' ) {
            input = InpPipe;
        } else if ( c == 'C' ) {
            input = InpC;
        } else if ( c == 'E' ) {
            input = InpE;
        } else if ( c == 'I' ) {
            input = InpI;
        } else if ( c == 'M' ) {
            input = InpM;
        } else if ( c == 'N' ) {
            input = InpN;
        } else if ( c == 'O' ) {
            input = InpO;
        } else if ( c == 'R' ) {
            input = InpR;
        } else if ( c == 'S' ) {
            input = InpS;
        } else if ( c == 'Y' ) {
            input = InpY;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case ST:
                parseOk = parseString( "CDATA" );
                break;
            case TTI:
                parseOk = parseString( "ID" );
                break;
            case TTI2:
                parseOk = parseString( "REF" );
                break;
            case TTI3:
                next(); // S
                break;
            case TTE:
                parseOk = parseString( "ENTIT" );
                break;
            case TTEY:
                next(); // Y
                break;
            case TTEI:
                parseOk = parseString( "IES" );
                break;
            case N:
                next(); // N
                break;
            case TTNM:
                parseOk = parseString( "MTOKEN" );
                break;
            case TTNM2:
                next(); // S
                break;
            case NO:
                parseOk = parseString( "OTATION" );
                break;
            case NO2:
                eat_ws();
                break;
            case NO3:
                next_eat_ws();
                break;
            case NOName:
                parseOk = parseName();
                break;
            case NO4:
                eat_ws();
                break;
            case EN:
                next_eat_ws();
                break;
            case ENNmt:
                parseOk = parseNmtoken();
                break;
            case EN2:
                eat_ws();
                break;
            case ADone:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case ST:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case TTI:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case TTI2:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case TTE:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case TTEI:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case TTNM:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case NO:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case NOName:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                break;
            case ENNmt:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNMTOKEN;
                    goto parseError;
                }
                break;
            case ADone:
                return TRUE;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_LETTEREXPECTED;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseAttValue ( )

private

Parse a AttValue [10]

Precondition: the head stands on the beginning " or '

If this function was successful, the head stands on the first character after the closing " or ' and the value of the attribute is in string().

Definition at line 4330 of file qxml.cpp.

{
    bool tmp;

    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;

    // use some kind of state machine for parsing
    static 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( c == '"' ) {
            input = InpDq;
        } else if ( c == '\'' ) {
            input = InpSq;
        } else if ( c == '&' ) {
            input = InpAmp;
        } else if ( c == '<' ) {
            input = InpLt;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Dq:
            case Sq:
                stringClear();
                next();
                break;
            case DqRef:
            case SqRef:
                parseOk = parseReference( tmp, InAttributeValue );
                break;
            case DqC:
            case SqC:
                stringAddC();
                next();
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case DqRef:
            case SqRef:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGREFERENCE;
                    goto parseError;
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_UNEXPECTEDCHARACTER;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseChoiceSeq ( )

private

Parse choice [49] or seq [50].

Precondition: the beginning '('S? is already read and the head stands on the first non-whitespace character after it.

Definition at line 4786 of file qxml.cpp.

{
    const signed char Init             = 0;
    const signed char Ws1              = 1; // eat whitespace
    const signed char CS_              = 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;

    // use some kind of state machine for parsing
    static 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,     CS_,   -1,    -1,    -1,     -1,      -1,      -1,      CS_    }, // 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == '(' ) {
            input = InpOp;
        } else if ( c == ')' ) {
            input = InpCp;
        } else if ( c == '?' ) {
            input = InpQm;
        } else if ( c == '*' ) {
            input = InpAst;
        } else if ( c == '+' ) {
            input = InpPlus;
        } else if ( c == '|' ) {
            input = InpPipe;
        } else if ( c == ',' ) {
            input = InpComm;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Ws1:
                next_eat_ws();
                break;
            case CS_:
                parseOk = parseChoiceSeq();
                break;
            case Ws2:
                next_eat_ws();
                break;
            case More:
                next_eat_ws();
                break;
            case Name:
                parseOk = parseName();
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case CS_:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGCHOICE;
                    goto parseError;
                }
                break;
            case Name:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_UNEXPECTEDCHARACTER;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseComment ( )

private

Parse a comment [15].

Precondition: the beginning '<!' of the comment is already read and the head stands on the first '-' of '

Definition at line 5297 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;

    // use some kind of state machine for parsing
    static 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 = Init;
    signed char input;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( c == '-' ) {
            input = InpDash;
        } else if ( c == '>' ) {
            input = InpGt;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        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;
        }
        // no input is read after this
        switch ( state ) {
            case Dash2:
                stringClear();
                break;
            case Com2:
                // if next character is not a dash than don't skip it
                if ( c != '-' ) {
                    stringAddC( '-' );
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_ERRORPARSINGCOMMENT;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseContent ( )

private

Parse a content [43].

A content is only used between tags. If a end tag is found the < is already read and the head stand on the '/' of the end tag '</name>'.

Definition at line 2635 of file qxml.cpp.

{
    bool charDataRead = FALSE;

    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 PI               =  6; // PI
    const signed char Elem             =  7; // Element
    const signed char Em               =  8; // '!' read
    const signed char Com              =  9; // Comment
    const signed char CDS              = 10; // CDSect
    const signed char CDS1             = 11; // read a CDSect
    const signed char CDS2             = 12; // read a CDSect (help state)
    const signed char CDS3             = 13; // read a CDSect (help state)
    const signed char Done             = 14; // 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 signed char mapCLT2FSMChar[] = {
        InpUnknown, // white space
        InpUnknown, // %
        InpAmp,     // &
        InpGt,      // >
        InpLt,      // <
        InpSlash,   // /
        InpQMark,   // ?
        InpEMark,   // !
        InpDash,    // -
        InpCloseB,  // ]
        InpOpenB,   // [
        InpUnknown, // =
        InpUnknown, // "
        InpUnknown, // '
        InpUnknown  // unknown
    };

    // use some kind of state machine for parsing
    static signed char const table[14][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,     PI,       Em,       -1,     -1,      -1,       -1,        Elem }, // Lt
        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // PI (same as Init)
        { 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)
        { 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input (use lookup-table instead of nested ifs for performance
        // reasons)
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if ( c.row() ) {
            input = InpUnknown;
        } else {
            input = mapCLT2FSMChar[ charLookupTable[ c.cell() ] ];
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Init:
                // next character
                next();
                break;
            case ChD:
                // on first call: clear string
                if ( !charDataRead ) {
                    charDataRead = TRUE;
                    stringClear();
                }
                stringAddC();
                next();
                break;
            case ChD1:
                // on first call: clear string
                if ( !charDataRead ) {
                    charDataRead = TRUE;
                    stringClear();
                }
                stringAddC();
                next();
                break;
            case ChD2:
                stringAddC();
                next();
                break;
            case Ref:
                if ( !charDataRead) {
                    // reference may be CharData; so clear string to be safe
                    stringClear();
                    parseOk = parseReference( charDataRead, InContent );
                } else {
                    bool tmp;
                    parseOk = parseReference( tmp, InContent );
                }
                break;
            case Lt:
                // call the handler for CharData
                if ( contentHnd ) {
                    if ( charDataRead ) {
                        if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
                            if ( !contentHnd->characters( string() ) ) {
                                d->error = contentHnd->errorString();
                                goto parseError;
                            }
                        }
                    }
                }
                charDataRead = FALSE;
                // next character
                next();
                break;
            case PI:
                parseOk = parsePI();
                break;
            case Elem:
                parseOk = parseElement();
                break;
            case Em:
                // next character
                next();
                break;
            case Com:
                parseOk = parseComment();
                break;
            case CDS:
                parseOk = parseString( "[CDATA[" );
                break;
            case CDS1:
                // read one character and add it
                stringAddC();
                next();
                break;
            case CDS2:
                // skip ']'
                next();
                break;
            case CDS3:
                // skip ']'...
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Ref:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGREFERENCE;
                    goto parseError;
                }
                break;
            case PI:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGPI;
                    goto parseError;
                }
                // call the handler
                if ( contentHnd ) {
                    if ( !contentHnd->processingInstruction(name(),string()) ) {
                        d->error = contentHnd->errorString();
                        goto parseError;
                    }
                }
                break;
            case Elem:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGELEMENT;
                    goto parseError;
                }
                break;
            case Com:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGCOMMENT;
                    goto parseError;
                }
                if ( lexicalHnd ) {
                    if ( !lexicalHnd->comment( string() ) ) {
                        d->error = lexicalHnd->errorString();
                        goto parseError;
                    }
                }
                break;
            case CDS:
                if( !parseOk ) {
                    d->error = XMLERR_CDSECTHEADEREXPECTED;
                    goto parseError;
                }
                // empty string
                stringClear();
                break;
            case CDS2:
                if (c != ']') {
                    stringAddC( ']' );
                }
                break;
            case CDS3:
                // test if this skipping was legal
                if        ( c == '>' ) {
                    // the end of the CDSect
                    if ( lexicalHnd ) {
                        if ( !lexicalHnd->startCDATA() ) {
                            d->error = lexicalHnd->errorString();
                            goto parseError;
                        }
                    }
                    if ( contentHnd ) {
                        if ( !contentHnd->characters( string() ) ) {
                            d->error = contentHnd->errorString();
                            goto parseError;
                        }
                    }
                    if ( lexicalHnd ) {
                        if ( !lexicalHnd->endCDATA() ) {
                            d->error = lexicalHnd->errorString();
                            goto parseError;
                        }
                    }
                } else if (c == ']') {
                    // three or more ']'
                    stringAddC( ']' );
                } else {
                    // after ']]' comes another character
                    stringAddC( ']' );
                    stringAddC( ']' );
                }
                break;
            case Done:
                // call the handler for CharData
                if ( contentHnd ) {
                    if ( charDataRead ) {
                        if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
                            if ( !contentHnd->characters( string() ) ) {
                                d->error = contentHnd->errorString();
                                goto parseError;
                            }
                        }
                    }
                }
                // Done
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_ERRORPARSINGCONTENT;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseDoctype ( )

private

Parse a document type definition (doctypedecl [28]).

Precondition: the beginning '<!' of the doctype is already read the head stands on the 'D' of '<!DOCTYPE'.

If this funktion was successful, the head-position is on the first character after the document type definition.

Definition at line 3264 of file qxml.cpp.

{
    // some init-stuff
    d->systemId = QString::null;
    d->publicId = QString::null;

    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
    const signed char Ws3              =  6; // eat_ws
    const signed char MP               =  7; // markupdecl or PEReference
    const signed char PER              =  8; // PERReference
    const signed char Mup              =  9; // markupdecl
    const signed char Ws4              = 10; // eat_ws
    const signed char MPE              = 11; // end of markupdecl or PEReference
    const signed char Done             = 12;

    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;

    // use some kind of state machine for parsing
    static signed char table[12][8] = {
     /*  InpWs,  InpD       InpS       InpOB  InpCB  InpPer InpGt  InpUnknown */
        { -1,     Doctype,   -1,        -1,    -1,    -1,    -1,    -1        }, // Init
        { Ws1,    Doctype2,  Doctype2,  -1,    -1,    -1,    -1,    Doctype2  }, // 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
        { 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == 'D' ) {
            input = InpD;
        } else if ( c == 'S' ) {
            input = InpS;
        } else if ( c == 'P' ) {
            input = InpS;
        } else if ( c == '[' ) {
            input = InpOB;
        } else if ( c == ']' ) {
            input = InpCB;
        } else if ( c == '%' ) {
            input = InpPer;
        } else if ( c == '>' ) {
            input = InpGt;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Doctype:
                parseOk = parseString( "DOCTYPE" );
                break;
            case Ws1:
            case Ws2:
            case Ws3:
            case Ws4:
                eat_ws();
                break;
            case Doctype2:
                parseName();
                break;
            case Sys:
                parseOk = parseExternalID();
                break;
            case MP:
                next_eat_ws();
                break;
            case PER:
                parseOk = parsePEReference( InDTD );
                break;
            case Mup:
                parseOk = parseMarkupdecl();
                break;
            case MPE:
                next_eat_ws();
                break;
            case Done:
                if ( lexicalHnd ) {
                    if ( !lexicalHnd->endDTD() ) {
                        d->error = lexicalHnd->errorString();
                        goto parseError;
                    }
                }
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Doctype:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGDOCTYPE;
                    goto parseError;
                }
                if ( !is_S(c) ) {
                    d->error = XMLERR_ERRORPARSINGDOCTYPE;
                    goto parseError;
                }
                break;
            case Doctype2:
                d->doctype = name();
                if ( lexicalHnd ) {
                    if ( !lexicalHnd->startDTD( d->doctype, d->publicId, d->systemId ) ) {
                        d->error = lexicalHnd->errorString();
                        goto parseError;
                    }
                }
                break;
            case Sys:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGDOCTYPE;
                    goto parseError;
                }
                break;
            case PER:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGDOCTYPE;
                    goto parseError;
                }
                break;
            case Mup:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGDOCTYPE;
                    goto parseError;
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_ERRORPARSINGDOCTYPE;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseElement ( )

private

Parse an element [39].

Precondition: the opening '<' is already read.

Definition at line 2303 of file qxml.cpp.

{
    static QString uri, lname, prefix;
    static bool t;

    const signed char Init             =  0;
    const signed char ReadName         =  1;
    const signed char Ws1              =  2;
    const signed char STagEnd          =  3;
    const signed char STagEnd2         =  4;
    const signed char ETagBegin        =  5;
    const signed char ETagBegin2       =  6;
    const signed char Ws2              =  7;
    const signed char EmptyTag         =  8;
    const signed char Attribute        =  9;
    const signed char Ws3              = 10;
    const signed char Done             = 11;

    const signed char InpWs            = 0; // whitespace
    const signed char InpNameBe        = 1; // is_NameBeginning()
    const signed char InpGt            = 2; // >
    const signed char InpSlash         = 3; // /
    const signed char InpUnknown       = 4;

    // use some kind of state machine for parsing
    static signed char table[11][5] = {
     /*  InpWs      InpNameBe    InpGt        InpSlash     InpUnknown */
        { -1,        ReadName,    -1,          -1,          -1        }, // Init
        { Ws1,       Attribute,   STagEnd,     EmptyTag,    -1        }, // ReadName
        { -1,        Attribute,   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,       Attribute,   STagEnd,     EmptyTag,    -1        }, // Attribute
        { -1,        Attribute,   STagEnd,     EmptyTag,    -1        }  // Ws3
    };
    signed char state = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // read input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( is_NameBeginning(c) ) {
            input = InpNameBe;
        } else if ( c == '>' ) {
            input = InpGt;
        } else if ( c == '/' ) {
            input = InpSlash;
        } else {
            input = InpUnknown;
        }
        // get new state
//qDebug( "%d -%d(%c)-> %d", state, input, c.latin1(), table[state][input] );
        state = table[state][input];

        // in some cases do special actions depending on state
        switch ( state ) {
            case ReadName:
                parseOk = parseName();
                break;
            case Ws1:
            case Ws2:
            case Ws3:
                eat_ws();
                break;
            case STagEnd:
                // call the handler
                if ( contentHnd ) {
                    if ( d->useNamespaces ) {
                        d->namespaceSupport.processName( tags.top(), FALSE, uri, lname );
                        t = contentHnd->startElement( uri, lname, tags.top(), d->attList );
                    } else {
                        t = contentHnd->startElement( "", "", tags.top(), d->attList );
                    }
                    if ( !t ) {
                        d->error = contentHnd->errorString();
                        goto parseError;
                    }
                }
                next();
                break;
            case STagEnd2:
                parseOk = parseContent();
                break;
            case ETagBegin:
                next();
                break;
            case ETagBegin2:
                // get the name of the tag
                parseOk = parseName();
                break;
            case EmptyTag:
                if  ( tags.isEmpty() ) {
                    d->error = XMLERR_TAGMISMATCH;
                    goto parseError;
                }
                if ( !parseElementEmptyTag( t, uri, lname ) )
                    goto parseError;
                // next character
                next();
                break;
            case Attribute:
                // get name and value of attribute
                parseOk = parseAttribute();
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case ReadName:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                // store it on the stack
                tags.push( name() );
                // empty the attributes
                d->attList.qnameList.clear();
                d->attList.uriList.clear();
                d->attList.localnameList.clear();
                d->attList.valueList.clear();
                // namespace support?
                if ( d->useNamespaces ) {
                    d->namespaceSupport.pushContext();
                }
                break;
            case STagEnd2:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGCONTENT;
                    goto parseError;
                }
                break;
            case ETagBegin2:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                if ( !parseElementETagBegin2( uri, lname ) )
                    goto parseError;
                break;
            case Attribute:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGATTRIBUTE;
                    goto parseError;
                }
                if ( !parseElementAttribute( prefix, uri, lname ) )
                    goto parseError;
                break;
            case Done:
                return TRUE;
            case -1:
                d->error = XMLERR_ERRORPARSINGELEMENT;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseElementAttribute ( QString &  prefix, QString &  uri, QString &  lname  )

private

Helper to break down the size of the code in the case statement. Return FALSE on error, otherwise TRUE.

Definition at line 2589 of file qxml.cpp.

{
    // add the attribute to the list
    if ( d->useNamespaces ) {
        // is it a namespace declaration?
        d->namespaceSupport.splitName( name(), prefix, lname );
        if ( prefix == "xmlns" ) {
            // namespace declaration
            d->namespaceSupport.setPrefix( lname, string() );
            if ( d->useNamespacePrefixes ) {
                d->attList.qnameList.append( name() );
                d->attList.uriList.append( "" );
                d->attList.localnameList.append( "" );
                d->attList.valueList.append( string() );
            }
            // call the handler for prefix mapping
            if ( contentHnd ) {
                if ( !contentHnd->startPrefixMapping( lname, string() ) ) {
                    d->error = contentHnd->errorString();
                    return FALSE;
                }
            }
        } else {
            // no namespace delcaration
            d->namespaceSupport.processName( name(), TRUE, uri, lname );
            d->attList.qnameList.append( name() );
            d->attList.uriList.append( uri );
            d->attList.localnameList.append( lname );
            d->attList.valueList.append( string() );
        }
    } else {
        // no namespace support
        d->attList.qnameList.append( name() );
        d->attList.uriList.append( "" );
        d->attList.localnameList.append( "" );
        d->attList.valueList.append( string() );
    }
    return TRUE;
}

bool QXmlSimpleReader::parseElementDecl ( )

private

Parse a elementdecl [45].

Precondition: the beginning '<!E' is already read and the head stands on the 'L' of '<!ELEMENT'

Definition at line 4438 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;

    // use some kind of state machine for parsing
    static 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // read input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == '>' ) {
            input = InpGt;
        } else if ( c == '|' ) {
            input = InpPipe;
        } else if ( c == '(' ) {
            input = InpOp;
        } else if ( c == ')' ) {
            input = InpCp;
        } else if ( c == '#' ) {
            input = InpHash;
        } else if ( c == '?' ) {
            input = InpQm;
        } else if ( c == '*' ) {
            input = InpAst;
        } else if ( c == '+' ) {
            input = InpPlus;
        } else if ( c == 'A' ) {
            input = InpA;
        } else if ( c == 'E' ) {
            input = InpE;
        } else if ( c == 'L' ) {
            input = InpL;
        } else {
            input = InpUnknown;
        }
        // get new state
//qDebug( "%d -%d(%c)-> %d", state, input, c.latin1(), table[state][input] );
        state = table[state][input];

        // in some cases do special actions depending on state
        switch ( state ) {
            case Elem:
                parseOk = parseString( "LEMENT" );
                break;
            case Ws1:
                eat_ws();
                break;
            case Nam:
                parseOk = parseName();
                break;
            case Ws2:
                eat_ws();
                break;
            case Empty:
                parseOk = parseString( "EMPTY" );
                break;
            case Any:
                parseOk = parseString( "ANY" );
                break;
            case Cont:
                next_eat_ws();
                break;
            case Mix:
                parseOk = parseString( "#PCDATA" );
                break;
            case Mix2:
                eat_ws();
                break;
            case Mix3:
                next();
                break;
            case MixN1:
                next_eat_ws();
                break;
            case MixN2:
                parseOk = parseName();
                break;
            case MixN3:
                eat_ws();
                break;
            case MixN4:
                next();
                break;
            case Cp:
                parseOk = parseChoiceSeq();
                break;
            case Cp2:
                next();
                break;
            case WsD:
                next_eat_ws();
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Elem:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case Nam:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                break;
            case Empty:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case Any:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case Mix:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case MixN2:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                break;
            case Cp:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGCHOICE;
                    goto parseError;
                }
                break;
            case Done:
                return TRUE;
            case -1:
                d->error = XMLERR_UNEXPECTEDCHARACTER;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseElementEmptyTag ( bool &  t, QString &  uri, QString &  lname  )

private

Helper to break down the size of the code in the case statement. Return FALSE on error, otherwise TRUE.

Definition at line 2482 of file qxml.cpp.

{
    // pop the stack and call the handler
    if ( contentHnd ) {
        // report startElement first...
        if ( d->useNamespaces ) {
            d->namespaceSupport.processName( tags.top(), FALSE, uri, lname );
            t = contentHnd->startElement( uri, lname, tags.top(), d->attList );
        } else {
            t = contentHnd->startElement( "", "", tags.top(), d->attList );
        }
        if ( !t ) {
            d->error = contentHnd->errorString();
            return FALSE;
        }
        // ... followed by endElement
        if ( d->useNamespaces ) {
            if ( !contentHnd->endElement( uri, lname,tags.pop() ) ) {
                d->error = contentHnd->errorString();
                return FALSE;
            }
        }
        else {
            if ( !contentHnd->endElement( "","",tags.pop() ) ) {
                d->error = contentHnd->errorString();
                return FALSE;
            }
        }
        // namespace support?
        if ( d->useNamespaces ) {
            QStringList prefixesBefore, prefixesAfter;
            if ( contentHnd ) {
                prefixesBefore = d->namespaceSupport.prefixes();
            }
            d->namespaceSupport.popContext();
            // call the handler for prefix mapping
            if ( contentHnd ) {
                prefixesAfter = d->namespaceSupport.prefixes();
                for ( QStringList::Iterator it = prefixesBefore.begin(); it != prefixesBefore.end(); ++it ) {
                    if ( prefixesAfter.contains(*it) == 0 ) {
                        if ( !contentHnd->endPrefixMapping( *it ) ) {
                            d->error = contentHnd->errorString();
                            return FALSE;
                        }
                    }
                }
            }
        }
    } else {
        tags.pop();
    }
    return TRUE;
}

bool QXmlSimpleReader::parseElementETagBegin2 ( QString &  uri, QString &  lname  )

private

Helper to break down the size of the code in the case statement. Return FALSE on error, otherwise TRUE.

Definition at line 2539 of file qxml.cpp.

{

    // pop the stack and compare it with the name
    if ( tags.pop() != name() ) {
        d->error = XMLERR_TAGMISMATCH;
        return FALSE;
    }
    // call the handler
    if ( contentHnd ) {
        if ( d->useNamespaces ) {
                d->namespaceSupport.processName( name(), FALSE, uri, lname );
                if ( !contentHnd->endElement(uri,lname,name()) ) {
                    d->error = contentHnd->errorString();
                    return FALSE;
                }
        }
        else {
                if ( !contentHnd->endElement("","",name()) ) {
                    d->error = contentHnd->errorString();
                    return FALSE;
                }
        }
    }
    // namespace support?
    if ( d->useNamespaces ) {
        QStringList prefixesBefore, prefixesAfter;
        if ( contentHnd ) {
            prefixesBefore = d->namespaceSupport.prefixes();
        }
        d->namespaceSupport.popContext();
        // call the handler for prefix mapping
        if ( contentHnd ) {
            prefixesAfter = d->namespaceSupport.prefixes();
            for ( QStringList::Iterator it = prefixesBefore.begin(); it != prefixesBefore.end(); ++it ) {
                if ( prefixesAfter.contains(*it) == 0 ) {
                    if ( !contentHnd->endPrefixMapping( *it ) ) {
                        d->error = contentHnd->errorString();
                        return FALSE;
                    }
                }
            }
        }
    }
    return TRUE;
}

bool QXmlSimpleReader::parseEntityDecl ( )

private

Parse a EntityDecl [70].

Precondition: the beginning '<!E' is already read and the head stand on the 'N' of '<!ENTITY'

Definition at line 4908 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 ExtID            =  6; // parse ExternalID
    const signed char Ws3              =  7; // white space read
    const signed char Ndata            =  8; // parse "NDATA"
    const signed char Ws4              =  9; // white space read
    const signed char NNam             = 10; // parse name
    const signed char PEDec            = 11; // parse PEDecl
    const signed char Ws6              = 12; // white space read
    const signed char PENam            = 13; // parse name
    const signed char Ws7              = 14; // white space read
    const signed char PEVal            = 15; // parse entity value
    const signed char PEEID            = 16; // parse ExternalID
    const signed char WsE              = 17; // white space read
    const signed char EDDone           = 19; // done, but also report an external, unparsed entity decl
    const signed char Done             = 18;

    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;

    // use some kind of state machine for parsing
    static signed char table[18][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
        { 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
        { 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      }, // PEEID
        { -1,    -1,     -1,      Done,  -1,     -1      }  // WsE
    };
    signed char state = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == '%' ) {
            input = InpPer;
        } else if ( c == '"' || c == '\'' ) {
            input = InpQuot;
        } else if ( c == '>' ) {
            input = InpGt;
        } else if ( c == 'N' ) {
            input = InpN;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Ent:
                parseOk = parseString( "NTITY" );
                break;
            case Ws1:
                eat_ws();
                break;
            case Name:
                parseOk = parseName();
                break;
            case Ws2:
                eat_ws();
                break;
            case EValue:
                parseOk = parseEntityValue();
                break;
            case ExtID:
                parseOk = parseExternalID();
                break;
            case Ws3:
                eat_ws();
                break;
            case Ndata:
                parseOk = parseString( "NDATA" );
                break;
            case Ws4:
                eat_ws();
                break;
            case NNam:
                parseOk = parseName( TRUE );
                break;
            case PEDec:
                next();
                break;
            case Ws6:
                eat_ws();
                break;
            case PENam:
                parseOk = parseName();
                break;
            case Ws7:
                eat_ws();
                break;
            case PEVal:
                parseOk = parseEntityValue();
                break;
            case PEEID:
                parseOk = parseExternalID();
                break;
            case WsE:
                eat_ws();
                break;
            case EDDone:
                next();
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Ent:
                if ( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case Name:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                break;
            case EValue:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGENTITYVALUE;
                    goto parseError;
                }
                if (  !entityExist( name() ) ) {
                    d->entities.insert( name(), string() );
                    if ( declHnd ) {
                        if ( !declHnd->internalEntityDecl( name(), string() ) ) {
                            d->error = declHnd->errorString();
                            goto parseError;
                        }
                    }
                }
                break;
            case ExtID:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGEXTERNALID;
                    goto parseError;
                }
                break;
            case Ndata:
                if ( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case NNam:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                if (  !entityExist( name() ) ) {
                    d->externEntities.insert( name(), QXmlSimpleReaderPrivate::ExternEntity( d->publicId, d->systemId, ref() ) );
                    if ( dtdHnd ) {
                        if ( !dtdHnd->unparsedEntityDecl( name(), d->publicId, d->systemId, ref() ) ) {
                            d->error = declHnd->errorString();
                            goto parseError;
                        }
                    }
                }
                break;
            case PENam:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                break;
            case PEVal:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGENTITYVALUE;
                    goto parseError;
                }
                if (  !entityExist( name() ) ) {
                    d->parameterEntities.insert( name(), string() );
                    if ( declHnd ) {
                        if ( !declHnd->internalEntityDecl( QString("%")+name(), string() ) ) {
                            d->error = declHnd->errorString();
                            goto parseError;
                        }
                    }
                }
                break;
            case PEEID:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGEXTERNALID;
                    goto parseError;
                }
                if (  !entityExist( name() ) ) {
                    d->externParameterEntities.insert( name(), QXmlSimpleReaderPrivate::ExternParameterEntity( d->publicId, d->systemId ) );
                    if ( declHnd ) {
                        if ( !declHnd->externalEntityDecl( QString("%")+name(), d->publicId, d->systemId ) ) {
                            d->error = declHnd->errorString();
                            goto parseError;
                        }
                    }
                }
                break;
            case EDDone:
                if (  !entityExist( name() ) ) {
                    d->externEntities.insert( name(), QXmlSimpleReaderPrivate::ExternEntity( d->publicId, d->systemId, QString::null ) );
                    if ( declHnd ) {
                        if ( !declHnd->externalEntityDecl( name(), d->publicId, d->systemId ) ) {
                            d->error = declHnd->errorString();
                            goto parseError;
                        }
                    }
                }
                return TRUE;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_LETTEREXPECTED;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseEntityValue ( )

private

Parse a EntityValue [9]

Definition at line 5171 of file qxml.cpp.

{
    bool tmp;

    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;

    // use some kind of state machine for parsing
    static 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( c == '"' ) {
            input = InpDq;
        } else if ( c == '\'' ) {
            input = InpSq;
        } else if ( c == '&' ) {
            input = InpAmp;
        } else if ( c == '%' ) {
            input = InpPer;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Dq:
            case Sq:
                stringClear();
                next();
                break;
            case DqC:
            case SqC:
                stringAddC();
                next();
                break;
            case DqPER:
            case SqPER:
                parseOk = parsePEReference( InEntityValue );
                break;
            case DqRef:
            case SqRef:
                parseOk = parseReference( tmp, InEntityValue );
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case DqPER:
            case SqPER:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGDOCTYPE;
                    goto parseError;
                }
                break;
            case DqRef:
            case SqRef:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGREFERENCE;
                    goto parseError;
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_LETTEREXPECTED;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseExternalID ( bool  allowPublicID = FALSE )

private

Parse a ExternalID [75].

If allowPublicID is TRUE parse ExternalID [75] or PublicID [83].

Definition at line 3443 of file qxml.cpp.

{
    // some init-stuff
    d->systemId = QString::null;
    d->publicId = QString::null;

    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;

    // use some kind of state machine for parsing
    static 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == '\'' ) {
            input = InpSQ;
        } else if ( c == '"' ) {
            input = InpDQ;
        } else if ( c == 'S' ) {
            input = InpS;
        } else if ( c == 'P' ) {
            input = InpP;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Sys:
                parseOk = parseString( "SYSTEM" );
                break;
            case SysWS:
                eat_ws();
                break;
            case SysSQ:
            case SysDQ:
                stringClear();
                next();
                break;
            case SysSQ2:
            case SysDQ2:
                stringAddC();
                next();
                break;
            case Pub:
                parseOk = parseString( "PUBLIC" );
                break;
            case PubWS:
                eat_ws();
                break;
            case PubSQ:
            case PubDQ:
                stringClear();
                next();
                break;
            case PubSQ2:
            case PubDQ2:
                stringAddC();
                next();
                break;
            case PubE:
                next();
                break;
            case PubWS2:
                d->publicId = string();
                eat_ws();
                break;
            case Done:
                d->systemId = string();
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Sys:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case Pub:
                if( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case PDone:
                if ( allowPublicID ) {
                    d->publicId = string();
                    return TRUE;
                } else {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_UNEXPECTEDCHARACTER;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseMarkupdecl ( )

private

Parse a markupdecl [29].

Definition at line 3610 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;

    // use some kind of state machine for parsing
    static 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( c == '<' ) {
            input = InpLt;
        } else if ( c == '?' ) {
            input = InpQm;
        } else if ( c == '!' ) {
            input = InpEm;
        } else if ( c == '-' ) {
            input = InpDash;
        } else if ( c == 'A' ) {
            input = InpA;
        } else if ( c == 'E' ) {
            input = InpE;
        } else if ( c == 'L' ) {
            input = InpL;
        } else if ( c == 'N' ) {
            input = InpN;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Lt:
                next();
                break;
            case Em:
                next();
                break;
            case CE:
                next();
                break;
            case Qm:
                parseOk = parsePI();
                break;
            case Dash:
                parseOk = parseComment();
                break;
            case CA:
                parseOk = parseAttlistDecl();
                break;
            case CEL:
                parseOk = parseElementDecl();
                break;
            case CEN:
                parseOk = parseEntityDecl();
                break;
            case CN:
                parseOk = parseNotationDecl();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Qm:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGPI;
                    goto parseError;
                }
                if ( contentHnd ) {
                    if ( !contentHnd->processingInstruction(name(),string()) ) {
                        d->error = contentHnd->errorString();
                        goto parseError;
                    }
                }
                return TRUE;
            case Dash:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGCOMMENT;
                    goto parseError;
                }
                if ( lexicalHnd ) {
                    if ( !lexicalHnd->comment( string() ) ) {
                        d->error = lexicalHnd->errorString();
                        goto parseError;
                    }
                }
                return TRUE;
            case CA:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGATTLISTDECL;
                    goto parseError;
                }
                return TRUE;
            case CEL:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGELEMENTDECL;
                    goto parseError;
                }
                return TRUE;
            case CEN:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGENTITYDECL;
                    goto parseError;
                }
                return TRUE;
            case CN:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNOTATIONDECL;
                    goto parseError;
                }
                return TRUE;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_LETTEREXPECTED;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseMisc ( )

private

Parse Misc [27].

Definition at line 2922 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 PI               = 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;

    // use some kind of state machine for parsing
    static signed char table[3][5] = {
     /*  InpWs   InpLt  InpQm  InpEm     InpUnknown */
        { eatWS,  Lt,    -1,    -1,       -1        }, // Init
        { -1,     -1,    PI,    Comment,  -1        }, // Lt
        { -1,     -1,    -1,    -1,       Comment2  }  // Comment
    };
    signed char state = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == '<' ) {
            input = InpLt;
        } else if ( c == '?' ) {
            input = InpQm;
        } else if ( c == '!' ) {
            input = InpEm;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case eatWS:
                eat_ws();
                break;
            case Lt:
                next();
                break;
            case PI:
                parseOk = parsePI();
                break;
            case Comment:
                next();
                break;
            case Comment2:
                parseOk = parseComment();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case eatWS:
                return TRUE;
            case PI:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGPI;
                    goto parseError;
                }
                if ( contentHnd ) {
                    if ( !contentHnd->processingInstruction(name(),string()) ) {
                        d->error = contentHnd->errorString();
                        goto parseError;
                    }
                }
                return TRUE;
            case Comment2:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGCOMMENT;
                    goto parseError;
                }
                if ( lexicalHnd ) {
                    if ( !lexicalHnd->comment( string() ) ) {
                        d->error = lexicalHnd->errorString();
                        goto parseError;
                    }
                }
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_UNEXPECTEDCHARACTER;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseName ( bool  useRef = FALSE )

private

Parse a Name [5] and store the name in name or ref (if useRef is TRUE).

Definition at line 5498 of file qxml.cpp.

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

    const signed char InpNameBe        = 0; // name beginning signed characters
    const signed char InpNameCh        = 1; // NameChar without InpNameBe
    const signed char InpUnknown       = 2;

    // use some kind of state machine for parsing
    static signed char table[3][3] = {
     /*  InpNameBe  InpNameCh  InpUnknown */
        { Name1,     -1,        -1    }, // Init
        { Name,      Name,      Done  }, // Name1
        { Name,      Name,      Done  }  // Name
    };
    signed char state = Init;
    signed char input;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_NameBeginning(c) ) {
            input = InpNameBe;
        } else if ( is_NameChar(c) ) {
            input = InpNameCh;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Name1:
                if ( useRef ) {
                    refClear();
                    refAddC();
                } else {
                    nameClear();
                    nameAddC();
                }
                next();
                break;
            case Name:
                if ( useRef ) {
                    refAddC();
                } else {
                    nameAddC();
                }
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_LETTEREXPECTED;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseNmtoken ( )

private

Parse a Nmtoken [7] and store the name in name.

Definition at line 5580 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;

    // use some kind of state machine for parsing
    static signed char table[3][2] = {
     /*  InpNameCh  InpUnknown */
        { NameF,     -1    }, // Init
        { Name,      Done  }, // NameF
        { Name,      Done  }  // Name
    };
    signed char state = Init;
    signed char input;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if ( is_NameChar(c) ) {
            input = InpNameCh;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case NameF:
                nameClear();
                nameAddC();
                next();
                break;
            case Name:
                nameAddC();
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_LETTEREXPECTED;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseNotationDecl ( )

private

Parse a NotationDecl [82].

Precondition: the beginning '<!' is already read and the head stands on the 'N' of '<!NOTATION'

Definition at line 4661 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 Ws3              = 6; // eat whitespaces
    const signed char Done             = 7;

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

    // use some kind of state machine for parsing
    static signed char table[7][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
        { -1,     Done,  -1,     -1     }  // Ws3
    };
    signed char state = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == '>' ) {
            input = InpGt;
        } else if ( c == 'N' ) {
            input = InpN;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Not:
                parseOk = parseString( "NOTATION" );
                break;
            case Ws1:
                eat_ws();
                break;
            case Nam:
                parseOk = parseName();
                break;
            case Ws2:
                eat_ws();
                break;
            case ExtID:
                parseOk = parseExternalID( TRUE );
                break;
            case Ws3:
                eat_ws();
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Not:
                if ( !parseOk ) {
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                break;
            case Nam:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                break;
            case ExtID:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGEXTERNALID;
                    goto parseError;
                }
                // call the handler
                if ( dtdHnd ) {
                    if ( !dtdHnd->notationDecl( name(), d->publicId, d->systemId ) ) {
                        d->error = dtdHnd->errorString();
                        goto parseError;
                    }
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_UNEXPECTEDCHARACTER;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parsePEReference ( EntityRecognitionContext  context )

private

Parse a PEReference [69]

Definition at line 3776 of file qxml.cpp.

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

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

    // use some kind of state machine for parsing
    static signed char table[3][3] = {
     /*  InpSemi  InpPer  InpUnknown */
        { -1,      Next,   -1    }, // Init
        { -1,      -1,     Name  }, // Next
        { Done,    -1,     -1    }  // Name
    };
    signed char state = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( c == ';' ) {
            input = InpSemi;
        } else if ( c == '%' ) {
            input = InpPer;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case Next:
                next();
                break;
            case Name:
                parseOk = parseName( TRUE );
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Name:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                if ( d->parameterEntities.find( ref() ) == d->parameterEntities.end() ) {
                    // ### skip it???
                    if ( contentHnd ) {
                        if ( !contentHnd->skippedEntity( QString("%") + ref() ) ) {
                            d->error = contentHnd->errorString();
                            goto parseError;
                        }
                    }
                } else {
                    if ( context == InEntityValue ) {
                        // Included in literal
                        xmlRef = d->parameterEntities.find( ref() )
                            .data().replace( QRegExp("\""), """ ).replace( QRegExp("'"), "'" )
                            + xmlRef;
                    } else if ( context == InDTD ) {
                        // Included as PE
                        xmlRef = QString(" ") +
                            d->parameterEntities.find( ref() ).data() +
                            QString(" ") + xmlRef;
                    }
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_LETTEREXPECTED;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parsePI ( bool  xmldecl = FALSE )

private

Parse a processing instruction [16].

If xmldec is TRUE, it tries to parse a PI or a XML declaration [23].

Precondition: the beginning '<' of the PI is already read and the head stand on the '?' of '<?'.

If this funktion was successful, the head-position is on the first character after the PI.

Definition at line 3042 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 PI               =  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; // is_nameBeginning()
    const signed char InpGt            = 2; // >
    const signed char InpQm            = 3; // ?
    const signed char InpUnknown       = 4;

    // use some kind of state machine for parsing
    static 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     }, // PI
        { 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 = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( is_NameBeginning(c) ) {
            input = InpNameBe;
        } else if ( c == '>' ) {
            input = InpGt;
        } else if ( c == '?' ) {
            input = InpQm;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        switch ( state ) {
            case QmI:
                next();
                break;
            case Name:
                parseOk = parseName();
                break;
            case Ws1:
            case Ws2:
            case Ws3:
            case Ws4:
            case Ws5:
                eat_ws();
                break;
            case Version:
                parseOk = parseAttribute();
                break;
            case EorSD:
                parseOk = parseAttribute();
                break;
            case SD:
                // get the SDDecl (syntax like an attribute)
                if ( d->standalone != QXmlSimpleReaderPrivate::Unknown ) {
                    // already parsed the standalone declaration
                    d->error = XMLERR_UNEXPECTEDCHARACTER;
                    goto parseError;
                }
                parseOk = parseAttribute();
                break;
            case ADone:
                next();
                break;
            case Char:
                stringAddC();
                next();
                break;
            case Qm:
                // skip the '?'
                next();
                break;
            case Done:
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case Name:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGNAME;
                    goto parseError;
                }
                // test what name was read and determine the next state
                // (not very beautiful, I admit)
                if ( name().lower() == "xml" ) {
                    if ( xmldecl && name()=="xml" ) {
                        state = XMLDecl;
                    } else {
                        d->error = XMLERR_INVALIDNAMEFORPI;
                        goto parseError;
                    }
                } else {
                    state = PI;
                    stringClear();
                }
                break;
            case Version:
                // get version (syntax like an attribute)
                if ( !parseOk ) {
                    d->error = XMLERR_VERSIONEXPECTED;
                    goto parseError;
                }
                if ( name() != "version" ) {
                    d->error = XMLERR_VERSIONEXPECTED;
                    goto parseError;
                }
                d->xmlVersion = string();
                break;
            case EorSD:
                // get the EDecl or SDDecl (syntax like an attribute)
                if ( !parseOk ) {
                    d->error = XMLERR_EDECLORSDDECLEXPECTED;
                    goto parseError;
                }
                if        ( name() == "standalone" ) {
                    if ( string()=="yes" ) {
                        d->standalone = QXmlSimpleReaderPrivate::Yes;
                    } else if ( string()=="no" ) {
                        d->standalone = QXmlSimpleReaderPrivate::No;
                    } else {
                        d->error = XMLERR_WRONGVALUEFORSDECL;
                        goto parseError;
                    }
                } else if ( name() == "encoding" ) {
                    d->encoding = string();
                } else {
                    d->error = XMLERR_EDECLORSDDECLEXPECTED;
                    goto parseError;
                }
                break;
            case SD:
                if ( !parseOk ) {
                    d->error = XMLERR_SDDECLEXPECTED;
                    goto parseError;
                }
                if ( name() != "standalone" ) {
                    d->error = XMLERR_SDDECLEXPECTED;
                    goto parseError;
                }
                if ( string()=="yes" ) {
                    d->standalone = QXmlSimpleReaderPrivate::Yes;
                } else if ( string()=="no" ) {
                    d->standalone = QXmlSimpleReaderPrivate::No;
                } else {
                    d->error = XMLERR_WRONGVALUEFORSDECL;
                    goto parseError;
                }
                break;
            case Qm:
                // test if the skipping was legal
                if ( c != '>' ) {
                    stringAddC( '?' );
                }
                break;
            case Done:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_UNEXPECTEDCHARACTER;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseProlog ( )

private

Parses the prolog [22].

Definition at line 2131 of file qxml.cpp.

{
    bool xmldecl_possible = TRUE;
    bool doctype_read = FALSE;

    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 PI               = 6; // read PI
    const signed char Done             = 7;

    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;

    // use some kind of state machine for parsing
    static signed char table[7][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,    PI,    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      }  // PI
    };
    signed char state = Init;
    signed char input;
    bool parseOk = TRUE;

    while ( TRUE ) {

        // read input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if        ( is_S(c) ) {
            input = InpWs;
        } else if ( c == '<' ) {
            input = InpLt;
        } else if ( c == '?' ) {
            input = InpQm;
        } else if ( c == '!' ) {
            input = InpEm;
        } else if ( c == 'D' ) {
            input = InpD;
        } else if ( c == '-' ) {
            input = InpDash;
        } else {
            input = InpUnknown;
        }
        // get new state
        state = table[state][input];

        // in some cases do special actions depending on state
        switch ( state ) {
            case EatWS:
                // XML declaration only on first position possible
                xmldecl_possible = FALSE;
                // eat white spaces
                eat_ws();
                break;
            case Lt:
                // next character
                next();
                break;
            case Em:
                // XML declaration only on first position possible
                xmldecl_possible = FALSE;
                // next character
                next();
                break;
            case DocType:
                parseOk = parseDoctype();
                break;
            case Comment:
                parseOk = parseComment();
                break;
            case PI:
                parseOk = parsePI( xmldecl_possible );
                break;
        }
        // no input is read after this
        switch ( state ) {
            case DocType:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGPROLOG;
                    goto parseError;
                }
                if ( doctype_read ) {
                    d->error = XMLERR_MORETHANONEDOCTYPE;
                    goto parseError;
                } else {
                    doctype_read = FALSE;
                }
                break;
            case Comment:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGPROLOG;
                    goto parseError;
                }
                if ( lexicalHnd ) {
                    if ( !lexicalHnd->comment( string() ) ) {
                        d->error = lexicalHnd->errorString();
                        goto parseError;
                    }
                }
                break;
            case PI:
                if ( !parseOk ) {
                    d->error = XMLERR_ERRORPARSINGPROLOG;
                    goto parseError;
                }
                // call the handler
                if ( contentHnd ) {
                    if ( xmldecl_possible && !d->xmlVersion.isEmpty() ) {
                        QString value( "version = '" );
                        value += d->xmlVersion;
                        value += "'";
                        if ( !d->encoding.isEmpty() ) {
                            value += " encoding = '";
                            value += d->encoding;
                            value += "'";
                        }
                        if ( d->standalone == QXmlSimpleReaderPrivate::Yes ) {
                            value += " standalone = 'yes'";
                        } else if ( d->standalone == QXmlSimpleReaderPrivate::No ) {
                            value += " standalone = 'no'";
                        }
                        if ( !contentHnd->processingInstruction( "xml", value ) ) {
                            d->error = contentHnd->errorString();
                            goto parseError;
                        }
                    } else {
                        if ( !contentHnd->processingInstruction( name(), string() ) ) {
                            d->error = contentHnd->errorString();
                            goto parseError;
                        }
                    }
                }
                // XML declaration only on first position possible
                xmldecl_possible = FALSE;
                break;
            case Done:
                return TRUE;
            case -1:
                d->error = XMLERR_ERRORPARSINGELEMENT;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseReference ( bool &  charDataRead, EntityRecognitionContext  context  )

private

Parse a Reference [67].

charDataRead is set to TRUE if the reference must not be parsed. The character(s) which the reference mapped to are appended to string. The head stands on the first character after the reference.

charDataRead is set to FALSE if the reference must be parsed. The charachter(s) which the reference mapped to are inserted at the reference position. The head stands on the first character of the replacement).

Definition at line 5658 of file qxml.cpp.

{
    // temporary variables
    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;

    // use some kind of state machine for parsing
    static 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 = Init;
    signed char input;

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        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;
        }

        // set state according to input
        state = table[state][input];

        // do some actions according to state
        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( TRUE );
                break;
            case DoneD:
                tmp = ref().toUInt( &ok, 10 );
                if ( ok ) {
                    stringAddC( QChar(tmp) );
                } else {
                    d->error = XMLERR_ERRORPARSINGREFERENCE;
                    goto parseError;
                }
                charDataRead = TRUE;
                next();
                break;
            case DoneH:
                tmp = ref().toUInt( &ok, 16 );
                if ( ok ) {
                    stringAddC( QChar(tmp) );
                } else {
                    d->error = XMLERR_ERRORPARSINGREFERENCE;
                    goto parseError;
                }
                charDataRead = TRUE;
                next();
                break;
            case DoneN:
                if ( !processReference( charDataRead, context ) )
                    goto parseError;
                next();
                break;
        }
        // no input is read after this
        switch ( state ) {
            case DoneD:
                return TRUE;
            case DoneH:
                return TRUE;
            case DoneN:
                return TRUE;
            case -1:
                // Error
                d->error = XMLERR_ERRORPARSINGREFERENCE;
                goto parseError;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::parseString ( const QString &  s )

private

Parse over a simple string.

After the string was successfully parsed, the head is on the first character after the string.

Definition at line 5964 of file qxml.cpp.

{
    signed char Done                   = s.length();

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

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

    while ( TRUE ) {

        // get input
        if ( atEnd() ) {
            d->error = XMLERR_UNEXPECTEDEOF;
            goto parseError;
        }
        if ( c == s[(int)state] ) {
            input = InpCharExpected;
        } else {
            input = InpUnknown;
        }

        // set state according to input
        if ( input == InpCharExpected ) {
            state++;
        } else {
            // Error
            d->error = XMLERR_UNEXPECTEDCHARACTER;
            goto parseError;
        }

        // do some actions according to state
        next();
        // no input is read after this
        if ( state == Done ) {
            return TRUE;
        }

    }

    return TRUE;

parseError:
    reportParseError();
    return FALSE;
}

bool QXmlSimpleReader::processReference ( bool &  charDataRead, EntityRecognitionContext  context  )

private

Helper function for parseReference()

Definition at line 5805 of file qxml.cpp.

{
    QString reference = ref();
    if ( reference == "amp" ) {
        if ( context == InEntityValue ) {
            // Bypassed
            stringAddC( '&' ); stringAddC( 'a' ); stringAddC( 'm' ); stringAddC( 'p' ); stringAddC( ';' );
        } else {
            // Included or Included in literal
            stringAddC( '&' );
        }
        charDataRead = TRUE;
    } else if ( reference == "lt" ) {
        if ( context == InEntityValue ) {
            // Bypassed
            stringAddC( '&' ); stringAddC( 'l' ); stringAddC( 't' ); stringAddC( ';' );
        } else {
            // Included or Included in literal
            stringAddC( '<' );
        }
        charDataRead = TRUE;
    } else if ( reference == "gt" ) {
        if ( context == InEntityValue ) {
            // Bypassed
            stringAddC( '&' ); stringAddC( 'g' ); stringAddC( 't' ); stringAddC( ';' );
        } else {
            // Included or Included in literal
            stringAddC( '>' );
        }
        charDataRead = TRUE;
    } else if ( reference == "apos" ) {
        if ( context == InEntityValue ) {
            // Bypassed
            stringAddC( '&' ); stringAddC( 'a' ); stringAddC( 'p' ); stringAddC( 'o' ); stringAddC( 's' ); stringAddC( ';' );
        } else {
            // Included or Included in literal
            stringAddC( '\'' );
        }
        charDataRead = TRUE;
    } else if ( reference == "quot" ) {
        if ( context == InEntityValue ) {
            // Bypassed
            stringAddC( '&' ); stringAddC( 'q' ); stringAddC( 'u' ); stringAddC( 'o' ); stringAddC( 't' ); stringAddC( ';' );
        } else {
            // Included or Included in literal
            stringAddC( '"' );
        }
        charDataRead = TRUE;
    } else {
        QMap<QString,QString>::Iterator it;
        it = d->entities.find( reference );
        if ( it != d->entities.end() ) {
            // "Internal General"
            switch ( context ) {
                case InContent:
                    // Included
                    xmlRef = it.data() + xmlRef;
                    charDataRead = FALSE;
                    break;
                case InAttributeValue:
                    // Included in literal
                    xmlRef = it.data().replace( QRegExp("\""), "&quot;" ).replace( QRegExp("'"), "&apos;" )
                        + xmlRef;
                    charDataRead = FALSE;
                    break;
                case InEntityValue:
                    {
                        // Bypassed
                        stringAddC( '&' );
                        for ( int i=0; i<(int)reference.length(); i++ ) {
                            stringAddC( reference[i] );
                        }
                        stringAddC( ';');
                        charDataRead = TRUE;
                    }
                    break;
                case InDTD:
                    // Forbidden
                    d->error = XMLERR_INTERNALGENERALENTITYINDTD;
                    charDataRead = FALSE;
                    break;
            }
        } else {
            QMap<QString,QXmlSimpleReaderPrivate::ExternEntity>::Iterator itExtern;
            itExtern = d->externEntities.find( reference );
            if ( itExtern == d->externEntities.end() ) {
                // entity not declared
                // ### check this case for conformance
                if ( context == InEntityValue ) {
                    // Bypassed
                    stringAddC( '&' );
                    for ( int i=0; i<(int)reference.length(); i++ ) {
                        stringAddC( reference[i] );
                    }
                    stringAddC( ';');
                    charDataRead = TRUE;
                } else {
                    if ( contentHnd ) {
                        if ( !contentHnd->skippedEntity( reference ) ) {
                            d->error = contentHnd->errorString();
                            return FALSE; // error
                        }
                    }
                }
            } else if ( (*itExtern).notation.isNull() ) {
                // "External Parsed General"
                switch ( context ) {
                    case InContent:
                        // Included if validating
                        if ( contentHnd ) {
                            if ( !contentHnd->skippedEntity( reference ) ) {
                                d->error = contentHnd->errorString();
                                return FALSE; // error
                            }
                        }
                        charDataRead = FALSE;
                        break;
                    case InAttributeValue:
                        // Forbidden
                        d->error = XMLERR_EXTERNALGENERALENTITYINAV;
                        charDataRead = FALSE;
                        break;
                    case InEntityValue:
                        {
                            // Bypassed
                            stringAddC( '&' );
                            for ( int i=0; i<(int)reference.length(); i++ ) {
                                stringAddC( reference[i] );
                            }
                            stringAddC( ';');
                            charDataRead = TRUE;
                        }
                        break;
                    case InDTD:
                        // Forbidden
                        d->error = XMLERR_EXTERNALGENERALENTITYINDTD;
                        charDataRead = FALSE;
                        break;
                }
            } else {
                // "Unparsed"
                // ### notify for "Occurs as Attribute Value" missing (but this is no refence, anyway)
                // Forbidden
                d->error = XMLERR_UNPARSEDENTITYREFERENCE;
                charDataRead = FALSE;
                return FALSE; // error
            }
        }
    }
    return TRUE; // no error
}

void * QXmlSimpleReader::property ( const QString &  name, bool *  ok = 0  ) const

virtual

Returns 0 since this class does not support any properties.

Implements QXmlReader.

Definition at line 2004 of file qxml.cpp.

{
    if ( ok != 0 )
        *ok = FALSE;
    return 0;
}

QString & QXmlSimpleReader::ref ( )

inlineprivate

Definition at line 598 of file qxml.h.

{
    refValue += QString( refArray, refPos );
    refPos = 0;
    return refValue;
}

void QXmlSimpleReader::refAddC ( )

inlineprivate

Definition at line 628 of file qxml.h.

{
    if ( refPos >= 256 ) {
        refValue += QString( refArray, refPos );
        refPos = 0;
    }
    refArray[refPos++] = c;
}

void QXmlSimpleReader::refAddC ( const QChar &  ch )

inlineprivate

Definition at line 653 of file qxml.h.

{
    if ( refPos >= 256 ) {
        refValue += QString( refArray, refPos );
        refPos = 0;
    }
    refArray[refPos++] = ch;
}

void QXmlSimpleReader::refClear ( )

inlineprivate

Definition at line 609 of file qxml.h.

{ refValue = ""; refPos = 0; }

void QXmlSimpleReader::reportParseError ( )

private

Definition at line 6055 of file qxml.cpp.

{
    if ( errorHnd )
        errorHnd->fatalError( QXmlParseException( d->error, columnNr+1, lineNr+1 ) );
}

void QXmlSimpleReader::setContentHandler ( QXmlContentHandler *  handler )

virtual

Implements QXmlReader.

Definition at line 2043 of file qxml.cpp.

{ contentHnd = handler; }

void QXmlSimpleReader::setDeclHandler ( QXmlDeclHandler *  handler )

virtual

Implements QXmlReader.

Definition at line 2067 of file qxml.cpp.

{ declHnd = handler; }

void QXmlSimpleReader::setDTDHandler ( QXmlDTDHandler *  handler )

virtual

Implements QXmlReader.

Definition at line 2035 of file qxml.cpp.

{ dtdHnd = handler; }

void QXmlSimpleReader::setEntityResolver ( QXmlEntityResolver *  handler )

virtual

Implements QXmlReader.

Definition at line 2027 of file qxml.cpp.

{ entityRes = handler; }

void QXmlSimpleReader::setErrorHandler ( QXmlErrorHandler *  handler )

virtual

Implements QXmlReader.

Definition at line 2051 of file qxml.cpp.

{ errorHnd = handler; }

void QXmlSimpleReader::setFeature ( const QString &  name, bool  value  )

virtual

Sets the state of a feature.

Supported features are:

• http://xml.org/sax/features/namespaces: if this feature is TRUE, namespace processing is performed
• http://xml.org/sax/features/namespace-prefixes: if this feature is TRUE, the the original prefixed names and attributes used for namespace declarations are reported
• http://trolltech.com/xml/features/report-whitespace-only-CharData: if this feature is TRUE, CharData that consists only of whitespace (and no other characters) is not reported via QXmlContentHandler::characters()

See also

feature() hasFeature()

Implements QXmlReader.

Definition at line 1972 of file qxml.cpp.

{
    if        ( name == "http://xml.org/sax/features/namespaces" ) {
        d->useNamespaces = value;
    } else if ( name == "http://xml.org/sax/features/namespace-prefixes" ) {
        d->useNamespacePrefixes = value;
    } else if ( name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" ) {
        d->reportWhitespaceCharData = value;
    } else {
        qWarning( "Unknown feature %s", name.ascii() );
    }
}

void QXmlSimpleReader::setLexicalHandler ( QXmlLexicalHandler *  handler )

virtual

Implements QXmlReader.

Definition at line 2059 of file qxml.cpp.

{ lexicalHnd = handler; }

void QXmlSimpleReader::setProperty ( const QString &  name, void *  value  )

virtual

Does nothing since this class does not support any properties.

Implements QXmlReader.

Definition at line 2014 of file qxml.cpp.

{
}

QString & QXmlSimpleReader::string ( )

inlineprivate

Definition at line 586 of file qxml.h.

{
    stringValue += QString( stringArray, stringPos );
    stringPos = 0;
    return stringValue;
}

void QXmlSimpleReader::stringAddC ( )

inlineprivate

Definition at line 612 of file qxml.h.

{
    if ( stringPos >= 256 ) {
        stringValue += QString( stringArray, stringPos );
        stringPos = 0;
    }
    stringArray[stringPos++] = c;
}

void QXmlSimpleReader::stringAddC ( const QChar &  ch )

inlineprivate

Definition at line 637 of file qxml.h.

{
    if ( stringPos >= 256 ) {
        stringValue += QString( stringArray, stringPos );
        stringPos = 0;
    }
    stringArray[stringPos++] = ch;
}

void QXmlSimpleReader::stringClear ( )

inlineprivate

Definition at line 605 of file qxml.h.

{ stringValue = ""; stringPos = 0; }

Friends And Related Function Documentation

friend class QXmlLocator

friend

Definition at line 372 of file qxml.h.

friend class QXmlSimpleReaderPrivate

friend

Definition at line 371 of file qxml.h.

Member Data Documentation

QChar QXmlSimpleReader::c

private

Definition at line 276 of file qxml.h.

int QXmlSimpleReader::columnNr

private

Definition at line 278 of file qxml.h.

QXmlContentHandler* QXmlSimpleReader::contentHnd

private

Definition at line 269 of file qxml.h.

QXmlSimpleReaderPrivate* QXmlSimpleReader::d

private

Definition at line 297 of file qxml.h.

QXmlDeclHandler* QXmlSimpleReader::declHnd

private

Definition at line 274 of file qxml.h.

QXmlDTDHandler* QXmlSimpleReader::dtdHnd

private

Definition at line 271 of file qxml.h.

QXmlEntityResolver* QXmlSimpleReader::entityRes

private

Definition at line 272 of file qxml.h.

QXmlErrorHandler* QXmlSimpleReader::errorHnd

private

Definition at line 270 of file qxml.h.

QXmlLexicalHandler* QXmlSimpleReader::lexicalHnd

private

Definition at line 273 of file qxml.h.

int QXmlSimpleReader::lineNr

private

Definition at line 277 of file qxml.h.

QChar QXmlSimpleReader::nameArray[256]

private

Definition at line 282 of file qxml.h.

int QXmlSimpleReader::namePos

private

Definition at line 281 of file qxml.h.

QString QXmlSimpleReader::nameValue

private

Definition at line 283 of file qxml.h.

int QXmlSimpleReader::pos

private

Definition at line 279 of file qxml.h.

const QChar QXmlSimpleReader::QEOF = QChar((ushort)0xffff)

staticprivate

Definition at line 299 of file qxml.h.

QChar QXmlSimpleReader::refArray[256]

private

Definition at line 285 of file qxml.h.

int QXmlSimpleReader::refPos

private

Definition at line 284 of file qxml.h.

QString QXmlSimpleReader::refValue

private

Definition at line 286 of file qxml.h.

QChar QXmlSimpleReader::stringArray[256]

private

Definition at line 288 of file qxml.h.

int QXmlSimpleReader::stringPos

private

Definition at line 287 of file qxml.h.

QString QXmlSimpleReader::stringValue

private

Definition at line 289 of file qxml.h.

QValueStack<QString> QXmlSimpleReader::tags

private

Definition at line 295 of file qxml.h.

QString QXmlSimpleReader::xml

private

Definition at line 291 of file qxml.h.

int QXmlSimpleReader::xmlLength

private

Definition at line 292 of file qxml.h.

QString QXmlSimpleReader::xmlRef

private

Definition at line 293 of file qxml.h.

---

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

• doxygen-1.8.11/qtools/qxml.h
• doxygen-1.8.11/qtools/qxml.cpp