File: qxml-h.html

package info (click to toggle)
qt-embedded 2.3.2-3
links: PTS
area: main
in suites: woody
size: 68,608 kB
ctags: 45,998
sloc: cpp: 276,654; ansic: 71,987; makefile: 29,074; sh: 12,305; yacc: 2,465; python: 1,863; perl: 481; lex: 480; xml: 68; lisp: 15
file content (702 lines) | stat: -rw-r--r-- 22,870 bytes
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>
Qt Toolkit - qxml.h include file
</title><style type="text/css"><!--
h3.fn,span.fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
a:visited { color: #672967; text-decoration: none }body { background: white; color: black; }
--></style>
</head><body bgcolor="#ffffff">

<table width="100%">
<tr><td><a href="index.html">
<img width="100" height="100" src="qtlogo.png"
alt="Home" border="0"><img width="100"
height="100" src="face.png" alt="Home" border="0">
</a><td valign=top><div align=right><img src="dochead.png" width="472" height="27"><br>
<a href="classes.html"><b>Classes</b></a>
-<a href="annotated.html">Annotated</a>
- <a href="hierarchy.html">Tree</a>
-<a href="functions.html">Functions</a>
-<a href="index.html">Home</a>
-<a href="topicals.html"><b>Structure</b></a>
</div>
</table>

<h1 align=center>qxml.h</h1><br clear="all">
This is the verbatim text of the qxml.h include file.  It is
provided only for illustration; the copyright
remains with Trolltech.
<hr>
<pre>
/****************************************************************************
** &#36;Id&#58; qt/src/xml/qxml.h   2.3.2   edited 2001-01-26 $
**
** Definition of QXmlSimpleReader and related classes.
**
** Created : 000518
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
**
** This file is part of the XML module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition licenses may use this
** file in accordance with the Qt Commercial License Agreement provided
** with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#ifndef QXML_H
#define QXML_H

#include &lt;qmodules.h&gt;

#if !defined(QT_MODULE_XML)
#define QM_EXPORT
#else
#define QM_EXPORT Q_EXPORT
#endif

#ifndef QT_H
#include &lt;qtextstream.h&gt;
#include &lt;qfile.h&gt;
#include &lt;qstring.h&gt;
#include &lt;qstringlist.h&gt;
#include &lt;qvaluestack.h&gt;
#include &lt;qmap.h&gt;
#endif // QT_H

#ifndef QT_NO_XML

class <a href="qxmlnamespacesupport.html">QXmlNamespaceSupport</a>;
class <a href="qxmlattributes.html">QXmlAttributes</a>;
class <a href="qxmlcontenthandler.html">QXmlContentHandler</a>;
class <a href="qxmldefaulthandler.html">QXmlDefaultHandler</a>;
class <a href="qxmldtdhandler.html">QXmlDTDHandler</a>;
class <a href="qxmlentityresolver.html">QXmlEntityResolver</a>;
class <a href="qxmlerrorhandler.html">QXmlErrorHandler</a>;
class <a href="qxmllexicalhandler.html">QXmlLexicalHandler</a>;
class <a href="qxmldeclhandler.html">QXmlDeclHandler</a>;
class <a href="qxmlinputsource.html">QXmlInputSource</a>;
class <a href="qxmllocator.html">QXmlLocator</a>;
class <a href="qxmlnamespacesupport.html">QXmlNamespaceSupport</a>;
class <a href="qxmlparseexception.html">QXmlParseException</a>;

class <a href="qxmlreader.html">QXmlReader</a>;
class <a href="qxmlsimplereader.html">QXmlSimpleReader</a>;

class QXmlSimpleReaderPrivate;
class QXmlNamespaceSupportPrivate;
class QXmlAttributesPrivate;
class QXmlInputSourcePrivate;
class QXmlParseExceptionPrivate;
class QXmlLocatorPrivate;
class QXmlDefaultHandlerPrivate;


//
// SAX Namespace Support
//

#if defined(Q_TEMPLATEDLL)
// MOC_SKIP_BEGIN
template class QM_EXPORT QMap&lt;QString, QString&gt;;
template class QM_EXPORT QValueStack&lt;QMap&lt;QString, QString&gt; &gt;;
template class QM_EXPORT QValueStack&lt;QString&gt;;
// MOC_SKIP_END
#endif

class QM_EXPORT <a href="qxmlnamespacesupport.html">QXmlNamespaceSupport</a>
{
public:
    QXmlNamespaceSupport();
    ~QXmlNamespaceSupport();

    void setPrefix( const QString&amp;, const QString&amp; );

    QString prefix( const QString&amp; ) const;
    QString uri( const QString&amp; ) const;
    void splitName( const QString&amp;, QString&amp;, QString&amp; ) const;
    void processName( const QString&amp;, bool, QString&amp;, QString&amp; ) const;
    QStringList prefixes() const;
    QStringList prefixes( const QString&amp; ) const;

    void pushContext();
    void popContext();
    void reset();
private:
    QValueStack&lt;QMap&lt;QString, QString&gt; &gt; nsStack;
    QMap&lt;QString, QString&gt; ns;

    QXmlNamespaceSupportPrivate *d;
};


//
// SAX Attributes
//

class QM_EXPORT <a href="qxmlattributes.html">QXmlAttributes</a>
{
public:
    QXmlAttributes() {}
    virtual ~QXmlAttributes() {}

    int index( const QString&amp; qName ) const;
    int index( const QString&amp; uri, const QString&amp; localPart ) const;
    int length() const;
    QString localName( int index ) const;
    QString qName( int index ) const;
    QString uri( int index ) const;
    QString type( int index ) const;
    QString type( const QString&amp; qName ) const;
    QString type( const QString&amp; uri, const QString&amp; localName ) const;
    QString value( int index ) const;
    QString value( const QString&amp; qName ) const;
    QString value( const QString&amp; uri, const QString&amp; localName ) const;

private:
    QStringList qnameList;
    QStringList uriList;
    QStringList localnameList;
    QStringList valueList;

    QXmlAttributesPrivate *d;

    friend class QXmlSimpleReader;
};

//
// SAX Input Source
//

class QM_EXPORT <a href="qxmlinputsource.html">QXmlInputSource</a>
{
public:
    QXmlInputSource();
    QXmlInputSource( QTextStream&amp; stream );
    QXmlInputSource( QFile&amp; file );
    virtual ~QXmlInputSource();

    virtual const QString&amp; data() const;
    virtual void setData( const QString&amp; d );

private:
    void readInput( QByteArray&amp; rawData );

    QString input;

    QXmlInputSourcePrivate *d;
};

//
// SAX Exception Classes
//

class QM_EXPORT <a href="qxmlparseexception.html">QXmlParseException</a>
{
public:
    QXmlParseException( const QString&amp; name="", int c=-1, int l=-1, const QString&amp; p="", const QString&amp; s="" )
        : msg( name ), column( c ), line( l ), pub( p ), sys( s )
    { }

    int columnNumber() const;
    int lineNumber() const;
    QString publicId() const;
    QString systemId() const;
    QString message() const;

private:
    QString msg;
    int column;
    int line;
    QString pub;
    QString sys;

    QXmlParseExceptionPrivate *d;
};


//
// XML Reader
//

class QM_EXPORT <a href="qxmlreader.html">QXmlReader</a>
{
public:
    virtual bool feature( const QString&amp; name, bool *ok = 0 ) const = 0;
    virtual void setFeature( const QString&amp; name, bool value ) = 0;
    virtual bool hasFeature( const QString&amp; name ) const = 0;
    virtual void* property( const QString&amp; name, bool *ok = 0 ) const = 0;
    virtual void setProperty( const QString&amp; name, void* value ) = 0;
    virtual bool hasProperty( const QString&amp; name ) const = 0;
    virtual void setEntityResolver( QXmlEntityResolver* handler ) = 0;
    virtual QXmlEntityResolver* entityResolver() const = 0;
    virtual void setDTDHandler( QXmlDTDHandler* handler ) = 0;
    virtual QXmlDTDHandler* DTDHandler() const = 0;
    virtual void setContentHandler( QXmlContentHandler* handler ) = 0;
    virtual QXmlContentHandler* contentHandler() const = 0;
    virtual void setErrorHandler( QXmlErrorHandler* handler ) = 0;
    virtual QXmlErrorHandler* errorHandler() const = 0;
    virtual void setLexicalHandler( QXmlLexicalHandler* handler ) = 0;
    virtual QXmlLexicalHandler* lexicalHandler() const = 0;
    virtual void setDeclHandler( QXmlDeclHandler* handler ) = 0;
    virtual QXmlDeclHandler* declHandler() const = 0;
    virtual bool parse( const QXmlInputSource&amp; input ) = 0;
};

class QM_EXPORT <a href="qxmlsimplereader.html">QXmlSimpleReader</a> : public <a href="qxmlreader.html">QXmlReader</a>
{
public:
    QXmlSimpleReader();
    virtual ~QXmlSimpleReader();

    bool feature( const QString&amp; name, bool *ok = 0 ) const;
    void setFeature( const QString&amp; name, bool value );
    bool hasFeature( const QString&amp; name ) const;

    void* property( const QString&amp; name, bool *ok = 0 ) const;
    void setProperty( const QString&amp; name, void* value );
    bool hasProperty( const QString&amp; 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&amp; input );

private:
    // variables
    QXmlContentHandler* contentHnd;
    QXmlErrorHandler*   errorHnd;
    QXmlDTDHandler*     dtdHnd;
    QXmlEntityResolver* entityRes;
    QXmlLexicalHandler* lexicalHnd;
    QXmlDeclHandler*    declHnd;

    QChar c; // the character at reading position
    int lineNr; // number of line
    int columnNr; // position in line
    int pos; // position in string

    int     namePos;
    QChar   nameArray[256]; // only used for names
    QString nameValue; // only used for names
    int     refPos;
    QChar   refArray[256]; // only used for references
    QString refValue; // only used for references
    int     stringPos;
    QChar   stringArray[256]; // used for any other strings that are parsed
    QString stringValue; // used for any other strings that are parsed

    QString xml;
    int xmlLength;
    QString xmlRef; // used for parsing of entity references

    QValueStack&lt;QString&gt; tags;

    QXmlSimpleReaderPrivate* d;

    static const QChar QEOF;

    // inlines
    virtual bool is_S( const QChar&amp; );
    virtual bool is_Letter( const QChar&amp; );
    virtual bool is_NameBeginning( const QChar&amp; );
    virtual bool is_Digit( const QChar&amp; );
    virtual bool is_CombiningChar( const QChar&amp; );
    virtual bool is_Extender( const QChar&amp; );
    virtual bool is_NameChar( const QChar&amp; );

    QString&amp; string();
    void stringClear();
    void stringAddC();
    void stringAddC(const QChar&amp;);
    QString&amp; name();
    void nameClear();
    void nameAddC();
    void nameAddC(const QChar&amp;);
    QString&amp; ref();
    void refClear();
    void refAddC();
    void refAddC(const QChar&amp;);

    // used by parseReference() and parsePEReference()
    enum EntityRecognitionContext { InContent, InAttributeValue, InEntityValue, InDTD };

    // private functions
    void eat_ws();
    void next_eat_ws();

    void next();
    bool atEnd();

    void init( const QXmlInputSource&amp; i );

    bool entityExist( const QString&amp; ) const;

    bool parseProlog();
    bool parseElement();
    bool parseElementEmptyTag( bool &amp;t, QString &amp;uri, QString &amp;lname );
    bool parseElementETagBegin2();
    bool parseElementAttribute( QString &amp;prefix, QString &amp;uri, QString &amp;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 &amp;charDataRead, EntityRecognitionContext context );
    bool processReference( bool &amp;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&amp; s );

    void reportParseError();

    friend class QXmlSimpleReaderPrivate;
    friend class QXmlLocator;
};

//
// SAX Locator
//

class QM_EXPORT <a href="qxmllocator.html">QXmlLocator</a>
{
public:
    QXmlLocator( QXmlSimpleReader* parent )
    { reader = parent; }
    ~QXmlLocator()
    { }

    int columnNumber();
    int lineNumber();
//    QString getPublicId()
//    QString getSystemId()

private:
    QXmlSimpleReader* reader;

    QXmlLocatorPrivate *d;
};

//
// SAX handler classes
//

class QM_EXPORT <a href="qxmlcontenthandler.html">QXmlContentHandler</a>
{
public:
    virtual void setDocumentLocator( QXmlLocator* locator ) = 0;
    virtual bool startDocument() = 0;
    virtual bool endDocument() = 0;
    virtual bool startPrefixMapping( const QString&amp; prefix, const QString&amp; uri ) = 0;
    virtual bool endPrefixMapping( const QString&amp; prefix ) = 0;
    virtual bool startElement( const QString&amp; namespaceURI, const QString&amp; localName, const QString&amp; qName, const QXmlAttributes&amp; atts ) = 0;
    virtual bool endElement( const QString&amp; namespaceURI, const QString&amp; localName, const QString&amp; qName ) = 0;
    virtual bool characters( const QString&amp; ch ) = 0;
    virtual bool ignorableWhitespace( const QString&amp; ch ) = 0;
    virtual bool processingInstruction( const QString&amp; target, const QString&amp; data ) = 0;
    virtual bool skippedEntity( const QString&amp; name ) = 0;
    virtual QString errorString() = 0;
};

class QM_EXPORT <a href="qxmlerrorhandler.html">QXmlErrorHandler</a>
{
public:
    virtual bool warning( const QXmlParseException&amp; exception ) = 0;
    virtual bool error( const QXmlParseException&amp; exception ) = 0;
    virtual bool fatalError( const QXmlParseException&amp; exception ) = 0;
    virtual QString errorString() = 0;
};

class QM_EXPORT <a href="qxmldtdhandler.html">QXmlDTDHandler</a>
{
public:
    virtual bool notationDecl( const QString&amp; name, const QString&amp; publicId, const QString&amp; systemId ) = 0;
    virtual bool unparsedEntityDecl( const QString&amp; name, const QString&amp; publicId, const QString&amp; systemId, const QString&amp; notationName ) = 0;
    virtual QString errorString() = 0;
};

class QM_EXPORT <a href="qxmlentityresolver.html">QXmlEntityResolver</a>
{
public:
    virtual bool resolveEntity( const QString&amp; publicId, const QString&amp; systemId, QXmlInputSource* ret ) = 0;
    virtual QString errorString() = 0;
};

class QM_EXPORT <a href="qxmllexicalhandler.html">QXmlLexicalHandler</a>
{
public:
    virtual bool startDTD( const QString&amp; name, const QString&amp; publicId, const QString&amp; systemId ) = 0;
    virtual bool endDTD() = 0;
//    virtual bool startEntity( const QString&amp; name ) = 0;
//    virtual bool endEntity( const QString&amp; name ) = 0;
    virtual bool startCDATA() = 0;
    virtual bool endCDATA() = 0;
    virtual bool comment( const QString&amp; ch ) = 0;
    virtual QString errorString() = 0;
};

class QM_EXPORT <a href="qxmldeclhandler.html">QXmlDeclHandler</a>
{
public:
    virtual bool attributeDecl( const QString&amp; eName, const QString&amp; aName, const QString&amp; type, const QString&amp; valueDefault, const QString&amp; value ) = 0;
    virtual bool internalEntityDecl( const QString&amp; name, const QString&amp; value ) = 0;
    virtual bool externalEntityDecl( const QString&amp; name, const QString&amp; publicId, const QString&amp; systemId ) = 0;
    virtual QString errorString() = 0;
};


class QM_EXPORT <a href="qxmldefaulthandler.html">QXmlDefaultHandler</a> : public <a href="qxmlcontenthandler.html">QXmlContentHandler</a>, public <a href="qxmlerrorhandler.html">QXmlErrorHandler</a>, public <a href="qxmldtdhandler.html">QXmlDTDHandler</a>, public <a href="qxmlentityresolver.html">QXmlEntityResolver</a>, public <a href="qxmllexicalhandler.html">QXmlLexicalHandler</a>, public <a href="qxmldeclhandler.html">QXmlDeclHandler</a>
{
public:
    QXmlDefaultHandler() { }
    virtual ~QXmlDefaultHandler() { }

    void setDocumentLocator( QXmlLocator* locator );
    bool startDocument();
    bool endDocument();
    bool startPrefixMapping( const QString&amp; prefix, const QString&amp; uri );
    bool endPrefixMapping( const QString&amp; prefix );
    bool startElement( const QString&amp; namespaceURI, const QString&amp; localName, const QString&amp; qName, const QXmlAttributes&amp; atts );
    bool endElement( const QString&amp; namespaceURI, const QString&amp; localName, const QString&amp; qName );
    bool characters( const QString&amp; ch );
    bool ignorableWhitespace( const QString&amp; ch );
    bool processingInstruction( const QString&amp; target, const QString&amp; data );
    bool skippedEntity( const QString&amp; name );

    bool warning( const QXmlParseException&amp; exception );
    bool error( const QXmlParseException&amp; exception );
    bool fatalError( const QXmlParseException&amp; exception );

    bool notationDecl( const QString&amp; name, const QString&amp; publicId, const QString&amp; systemId );
    bool unparsedEntityDecl( const QString&amp; name, const QString&amp; publicId, const QString&amp; systemId, const QString&amp; notationName );

    bool resolveEntity( const QString&amp; publicId, const QString&amp; systemId, QXmlInputSource* ret );

    bool startDTD( const QString&amp; name, const QString&amp; publicId, const QString&amp; systemId );
    bool endDTD();
//    bool startEntity( const QString&amp; name );
//    bool endEntity( const QString&amp; name );
    bool startCDATA();
    bool endCDATA();
    bool comment( const QString&amp; ch );

    bool attributeDecl( const QString&amp; eName, const QString&amp; aName, const QString&amp; type, const QString&amp; valueDefault, const QString&amp; value );
    bool internalEntityDecl( const QString&amp; name, const QString&amp; value );
    bool externalEntityDecl( const QString&amp; name, const QString&amp; publicId, const QString&amp; systemId );

    QString errorString();

private:
    QXmlDefaultHandlerPrivate *d;
};

#ifdef _WS_QWS_
#ifdef QT_XML_CPP
#define inline
#else
#define QT_NO_XML_INLINE
#endif
#endif

#ifndef QT_NO_XML_INLINE
//
// inlines
//

inline bool QXmlSimpleReader::is_S(const QChar&amp; ch)
{ return ch==' ' || ch=='\t' || ch=='\n' || ch=='\r'; }

inline bool QXmlSimpleReader::is_Letter( const QChar&amp; ch )
{ return ch.isLetter(); }

inline bool QXmlSimpleReader::is_NameBeginning( const QChar&amp; ch )
{ return ch=='_' || ch==':' || ch.isLetter(); }

inline bool QXmlSimpleReader::is_Digit( const QChar&amp; ch )
{ return ch.isDigit(); }

inline bool QXmlSimpleReader::is_CombiningChar( const QChar&amp; )
{ return FALSE; }

inline bool QXmlSimpleReader::is_Extender( const QChar&amp; )
{ return FALSE; }

inline bool QXmlSimpleReader::is_NameChar( const QChar&amp; ch )
{
    return ch=='.' || ch=='-' || ch=='_' || ch==':' ||
        is_Letter(ch) || is_Digit(ch) ||
        is_CombiningChar(ch) || is_Extender(ch);
}

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

inline bool QXmlSimpleReader::atEnd()
{ return c == QEOF; }

inline void QXmlSimpleReader::eat_ws()
{ while ( !atEnd() &amp;&amp; is_S(c) ) next(); }

inline void QXmlSimpleReader::next_eat_ws()
{ next(); eat_ws(); }


// use buffers instead of QString::operator+= when single characters are read
inline QString&amp; QXmlSimpleReader::string()
{
    stringValue += QString( stringArray, stringPos );
    stringPos = 0;
    return stringValue;
}
inline QString&amp; QXmlSimpleReader::name()
{
    nameValue += QString( nameArray, namePos );
    namePos = 0;
    return nameValue;
}
inline QString&amp; QXmlSimpleReader::ref()
{
    refValue += QString( refArray, refPos );
    refPos = 0;
    return refValue;
}

inline void QXmlSimpleReader::stringClear()
{ stringValue = ""; stringPos = 0; }
inline void QXmlSimpleReader::nameClear()
{ nameValue = ""; namePos = 0; }
inline void QXmlSimpleReader::refClear()
{ refValue = ""; refPos = 0; }

inline void QXmlSimpleReader::stringAddC()
{
    if ( stringPos &gt;= 256 ) {
        stringValue += QString( stringArray, stringPos );
        stringPos = 0;
    }
    stringArray[stringPos++] = c;
}
inline void QXmlSimpleReader::nameAddC()
{
    if ( namePos &gt;= 256 ) {
        nameValue += QString( nameArray, namePos );
        namePos = 0;
    }
    nameArray[namePos++] = c;
}
inline void QXmlSimpleReader::refAddC()
{
    if ( refPos &gt;= 256 ) {
        refValue += QString( refArray, refPos );
        refPos = 0;
    }
    refArray[refPos++] = c;
}

inline void QXmlSimpleReader::stringAddC(const QChar&amp; ch)
{
    if ( stringPos &gt;= 256 ) {
        stringValue += QString( stringArray, stringPos );
        stringPos = 0;
    }
    stringArray[stringPos++] = ch;
}
inline void QXmlSimpleReader::nameAddC(const QChar&amp; ch)
{
    if ( namePos &gt;= 256 ) {
        nameValue += QString( nameArray, namePos );
        namePos = 0;
    }
    nameArray[namePos++] = ch;
}
inline void QXmlSimpleReader::refAddC(const QChar&amp; ch)
{
    if ( refPos &gt;= 256 ) {
        refValue += QString( refArray, refPos );
        refPos = 0;
    }
    refArray[refPos++] = ch;
}
#endif

#ifdef _WS_QWS_
#ifdef QT_XML_CPP
#undef inline
#endif
#endif

#endif //QT_NO_XML

#endif

</pre>
<p><address><hr><div align="center">
<table width="100%" cellspacing="0" border="0"><tr>
<td>Copyright  2001 Trolltech<td><a href="http://www.trolltech.com/trademarks.html">Trademarks</a>
<td align="right"><div align="right">Qt version 2.3.2</div>
</table></div></address></body></html>