1 files changed, 674 insertions, 0 deletions

diff --git a/qtcompat/xml/qxml.h b/qtcompat/xml/qxml.h
new file mode 100644
index 0000000..b772df9
--- a/dev/null
+++ b/qtcompat/xml/qxml.h
@@ -0,0 +1,674 @@
+/****************************************************************************
+** $Id$
+**
+** 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.
+**
+**********************************************************************/
+
+
+/******************************************
+ * DOM support is disabled in QT 2.3.7 for sharp zaurus.
+ * Because of that we copied the code from 2.3.7 into qtcompat and enabled it 
+ * there.
+ * Copyright (c) 2004 Ulf Schenk
+ * 
+ * $Id$
+ ******************************************/
+
+#ifndef QXML_H
+#define QXML_H
+
+#include <qmodules.h>
+
+//US #if !defined(QT_MODULE_XML)
+//US #define QM_EXPORT
+//US #else
+#define QM_EXPORT Q_EXPORT
+//US #endif
+
+#ifndef QT_H
+#include <qtextstream.h>
+#include <qfile.h>
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qvaluestack.h>
+#include <qmap.h>
+#endif // QT_H
+
+//US #ifndef QT_NO_XML
+
+class QXmlNamespaceSupport;
+class QXmlAttributes;
+class QXmlContentHandler;
+class QXmlDefaultHandler;
+class QXmlDTDHandler;
+class QXmlEntityResolver;
+class QXmlErrorHandler;
+class QXmlLexicalHandler;
+class QXmlDeclHandler;
+class QXmlInputSource;
+class QXmlLocator;
+class QXmlNamespaceSupport;
+class QXmlParseException;
+
+class QXmlReader;
+class QXmlSimpleReader;
+
+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<QString, QString>;
+template class QM_EXPORT QValueStack<QMap<QString, QString> >;
+template class QM_EXPORT QValueStack<QString>;
+// MOC_SKIP_END
+#endif
+
+class QM_EXPORT QXmlNamespaceSupport
+{
+public:
+    QXmlNamespaceSupport();
+    ~QXmlNamespaceSupport();
+
+    void setPrefix( const QString&, const QString& );
+
+    QString prefix( const QString& ) const;
+    QString uri( const QString& ) const;
+    void splitName( const QString&, QString&, QString& ) const;
+    void processName( const QString&, bool, QString&, QString& ) const;
+    QStringList prefixes() const;
+    QStringList prefixes( const QString& ) const;
+
+    void pushContext();
+    void popContext();
+    void reset();
+private:
+    QValueStack<QMap<QString, QString> > nsStack;
+    QMap<QString, QString> ns;
+
+    QXmlNamespaceSupportPrivate *d;
+};
+
+
+//
+// SAX Attributes
+//
+
+class QM_EXPORT QXmlAttributes
+{
+public:
+    QXmlAttributes() {}
+    virtual ~QXmlAttributes() {}
+
+    int index( const QString& qName ) const;
+    int index( const QString& uri, const QString& 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& qName ) const;
+    QString type( const QString& uri, const QString& localName ) const;
+    QString value( int index ) const;
+    QString value( const QString& qName ) const;
+    QString value( const QString& uri, const QString& localName ) const;
+
+private:
+    QStringList qnameList;
+    QStringList uriList;
+    QStringList localnameList;
+    QStringList valueList;
+
+    QXmlAttributesPrivate *d;
+
+    friend class QXmlSimpleReader;
+};
+
+//
+// SAX Input Source
+//
+
+class QM_EXPORT QXmlInputSource
+{
+public:
+    QXmlInputSource();
+    QXmlInputSource( QTextStream& stream );
+    QXmlInputSource( QFile& file );
+    virtual ~QXmlInputSource();
+
+    virtual const QString& data() const;
+    virtual void setData( const QString& d );
+
+private:
+    void readInput( QByteArray& rawData );
+
+    QString input;
+
+    QXmlInputSourcePrivate *d;
+};
+
+//
+// SAX Exception Classes
+//
+
+class QM_EXPORT QXmlParseException
+{
+public:
+    QXmlParseException( const QString& name="", int c=-1, int l=-1, const QString& p="", const QString& 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 QXmlReader
+{
+public:
+    virtual bool feature( const QString& name, bool *ok = 0 ) const = 0;
+    virtual void setFeature( const QString& name, bool value ) = 0;
+    virtual bool hasFeature( const QString& name ) const = 0;
+    virtual void* property( const QString& name, bool *ok = 0 ) const = 0;
+    virtual void setProperty( const QString& name, void* value ) = 0;
+    virtual bool hasProperty( const QString& 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& input ) = 0;
+};
+
+class QM_EXPORT QXmlSimpleReader : public QXmlReader
+{
+public:
+    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 );
+
+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<QString> tags;
+
+    QXmlSimpleReaderPrivate* d;
+
+    static const QChar QEOF;
+
+    // inlines
+    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&);
+
+    // 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& i );
+
+    bool entityExist( const QString& ) const;
+
+    bool parseProlog();
+    bool parseElement();
+    bool parseElementEmptyTag( bool &t, QString &uri, QString &lname );
+    bool parseElementETagBegin2();
+    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();
+
+    friend class QXmlSimpleReaderPrivate;
+    friend class QXmlLocator;
+};
+
+//
+// SAX Locator
+//
+
+class QM_EXPORT QXmlLocator
+{
+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 QXmlContentHandler
+{
+public:
+    virtual void setDocumentLocator( QXmlLocator* locator ) = 0;
+    virtual bool startDocument() = 0;
+    virtual bool endDocument() = 0;
+    virtual bool startPrefixMapping( const QString& prefix, const QString& uri ) = 0;
+    virtual bool endPrefixMapping( const QString& prefix ) = 0;
+    virtual bool startElement( const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts ) = 0;
+    virtual bool endElement( const QString& namespaceURI, const QString& localName, const QString& qName ) = 0;
+    virtual bool characters( const QString& ch ) = 0;
+    virtual bool ignorableWhitespace( const QString& ch ) = 0;
+    virtual bool processingInstruction( const QString& target, const QString& data ) = 0;
+    virtual bool skippedEntity( const QString& name ) = 0;
+    virtual QString errorString() = 0;
+};
+
+class QM_EXPORT QXmlErrorHandler
+{
+public:
+    virtual bool warning( const QXmlParseException& exception ) = 0;
+    virtual bool error( const QXmlParseException& exception ) = 0;
+    virtual bool fatalError( const QXmlParseException& exception ) = 0;
+    virtual QString errorString() = 0;
+};
+
+class QM_EXPORT QXmlDTDHandler
+{
+public:
+    virtual bool notationDecl( const QString& name, const QString& publicId, const QString& systemId ) = 0;
+    virtual bool unparsedEntityDecl( const QString& name, const QString& publicId, const QString& systemId, const QString& notationName ) = 0;
+    virtual QString errorString() = 0;
+};
+
+class QM_EXPORT QXmlEntityResolver
+{
+public:
+    virtual bool resolveEntity( const QString& publicId, const QString& systemId, QXmlInputSource* ret ) = 0;
+    virtual QString errorString() = 0;
+};
+
+class QM_EXPORT QXmlLexicalHandler
+{
+public:
+    virtual bool startDTD( const QString& name, const QString& publicId, const QString& systemId ) = 0;
+    virtual bool endDTD() = 0;
+//    virtual bool startEntity( const QString& name ) = 0;
+//    virtual bool endEntity( const QString& name ) = 0;
+    virtual bool startCDATA() = 0;
+    virtual bool endCDATA() = 0;
+    virtual bool comment( const QString& ch ) = 0;
+    virtual QString errorString() = 0;
+};
+
+class QM_EXPORT QXmlDeclHandler
+{
+public:
+    virtual bool attributeDecl( const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value ) = 0;
+    virtual bool internalEntityDecl( const QString& name, const QString& value ) = 0;
+    virtual bool externalEntityDecl( const QString& name, const QString& publicId, const QString& systemId ) = 0;
+    virtual QString errorString() = 0;
+};
+
+
+class QM_EXPORT QXmlDefaultHandler : public QXmlContentHandler, public QXmlErrorHandler, public QXmlDTDHandler, public QXmlEntityResolver, public QXmlLexicalHandler, public QXmlDeclHandler
+{
+public:
+    QXmlDefaultHandler() { }
+    virtual ~QXmlDefaultHandler() { }
+
+    void setDocumentLocator( QXmlLocator* locator );
+    bool startDocument();
+    bool endDocument();
+    bool startPrefixMapping( const QString& prefix, const QString& uri );
+    bool endPrefixMapping( const QString& prefix );
+    bool startElement( const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts );
+    bool endElement( const QString& namespaceURI, const QString& localName, const QString& qName );
+    bool characters( const QString& ch );
+    bool ignorableWhitespace( const QString& ch );
+    bool processingInstruction( const QString& target, const QString& data );
+    bool skippedEntity( const QString& name );
+
+    bool warning( const QXmlParseException& exception );
+    bool error( const QXmlParseException& exception );
+    bool fatalError( const QXmlParseException& exception );
+
+    bool notationDecl( const QString& name, const QString& publicId, const QString& systemId );
+    bool unparsedEntityDecl( const QString& name, const QString& publicId, const QString& systemId, const QString& notationName );
+
+    bool resolveEntity( const QString& publicId, const QString& systemId, QXmlInputSource* ret );
+
+    bool startDTD( const QString& name, const QString& publicId, const QString& systemId );
+    bool endDTD();
+//    bool startEntity( const QString& name );
+//    bool endEntity( const QString& name );
+    bool startCDATA();
+    bool endCDATA();
+    bool comment( const QString& ch );
+
+    bool attributeDecl( const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value );
+    bool internalEntityDecl( const QString& name, const QString& value );
+    bool externalEntityDecl( const QString& name, const QString& publicId, const QString& 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& ch)
+{ return ch==' ' || ch=='\t' || ch=='\n' || ch=='\r'; }
+
+inline bool QXmlSimpleReader::is_Letter( const QChar& ch )
+{ return ch.isLetter(); }
+
+inline bool QXmlSimpleReader::is_NameBeginning( const QChar& ch )
+{ return ch=='_' || ch==':' || ch.isLetter(); }
+
+inline bool QXmlSimpleReader::is_Digit( const QChar& ch )
+{ return ch.isDigit(); }
+
+inline bool QXmlSimpleReader::is_CombiningChar( const QChar& )
+{ return FALSE; }
+
+inline bool QXmlSimpleReader::is_Extender( const QChar& )
+{ return FALSE; }
+
+inline bool QXmlSimpleReader::is_NameChar( const QChar& 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 >= xmlLength ) {
+            c = QEOF;
+        } else {
+            c = xml[pos];
+            columnNr++;
+            pos++;
+        }
+    }
+}
+
+inline bool QXmlSimpleReader::atEnd()
+{ return c == QEOF; }
+
+inline void QXmlSimpleReader::eat_ws()
+{ while ( !atEnd() && 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& QXmlSimpleReader::string()
+{
+    stringValue += QString( stringArray, stringPos );
+    stringPos = 0;
+    return stringValue;
+}
+inline QString& QXmlSimpleReader::name()
+{
+    nameValue += QString( nameArray, namePos );
+    namePos = 0;
+    return nameValue;
+}
+inline QString& 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 >= 256 ) {
+        stringValue += QString( stringArray, stringPos );
+        stringPos = 0;
+    }
+    stringArray[stringPos++] = c;
+}
+inline void QXmlSimpleReader::nameAddC()
+{
+    if ( namePos >= 256 ) {
+        nameValue += QString( nameArray, namePos );
+        namePos = 0;
+    }
+    nameArray[namePos++] = c;
+}
+inline void QXmlSimpleReader::refAddC()
+{
+    if ( refPos >= 256 ) {
+        refValue += QString( refArray, refPos );
+        refPos = 0;
+    }
+    refArray[refPos++] = c;
+}
+
+inline void QXmlSimpleReader::stringAddC(const QChar& ch)
+{
+    if ( stringPos >= 256 ) {
+        stringValue += QString( stringArray, stringPos );
+        stringPos = 0;
+    }
+    stringArray[stringPos++] = ch;
+}
+inline void QXmlSimpleReader::nameAddC(const QChar& ch)
+{
+    if ( namePos >= 256 ) {
+        nameValue += QString( nameArray, namePos );
+        namePos = 0;
+    }
+    nameArray[namePos++] = ch;
+}
+inline void QXmlSimpleReader::refAddC(const QChar& ch)
+{
+    if ( refPos >= 256 ) {
+        refValue += QString( refArray, refPos );
+        refPos = 0;
+    }
+    refArray[refPos++] = ch;
+}
+#endif
+
+#ifdef _WS_QWS_
+#ifdef QT_XML_CPP
+#undef inline
+#endif
+#endif
+
+//US #endif //QT_NO_XML
+
+#endif