move xmlstream and qzip into thirdparty
This commit is contained in:
ws
parent
c20b96e370
commit
2bf549ba72
21 changed files with 1267 additions and 1274 deletions
|
|
@ -75,13 +75,14 @@ add_library (
|
|||
tempo.cpp sig.cpp pos.cpp fraction.cpp duration.cpp
|
||||
figuredbass.cpp rehearsalmark.cpp transpose.cpp
|
||||
property.cpp range.cpp elementmap.cpp notedot.cpp imageStore.cpp
|
||||
qzip.cpp audio.cpp splitMeasure.cpp joinMeasure.cpp
|
||||
audio.cpp splitMeasure.cpp joinMeasure.cpp
|
||||
cursor.cpp read114.cpp paste.cpp
|
||||
bsymbol.cpp marker.cpp jump.cpp stemslash.cpp ledgerline.cpp
|
||||
synthesizerstate.cpp mcursor.cpp groups.cpp mscoreview.cpp
|
||||
noteline.cpp spannermap.cpp
|
||||
bagpembell.cpp ambitus.cpp
|
||||
xmlstream.cpp xmlutils.cpp
|
||||
../thirdparty/qzip/qzip.cpp
|
||||
../thirdparty/xmlstream/xmlstream.cpp ../thirdparty/xmlstream/xmlutils.cpp
|
||||
)
|
||||
if (SCRIPT_INTERFACE)
|
||||
set_target_properties (
|
||||
|
|
|
|||
|
|
@ -440,7 +440,7 @@ Score::FileError Score::read114(XmlReader& e)
|
|||
e.unknown();
|
||||
}
|
||||
|
||||
if (e.error() != QXmlStreamReader::NoError)
|
||||
if (e.error() != XmlStreamReader::NoError)
|
||||
return FILE_BAD_FORMAT;
|
||||
|
||||
int n = nstaves();
|
||||
|
|
|
|||
|
|
@ -43,8 +43,8 @@
|
|||
#include "imageStore.h"
|
||||
#include "audio.h"
|
||||
#include "barline.h"
|
||||
#include "libmscore/qzipreader_p.h"
|
||||
#include "libmscore/qzipwriter_p.h"
|
||||
#include "thirdparty/qzip/qzipreader_p.h"
|
||||
#include "thirdparty/qzip/qzipwriter_p.h"
|
||||
#ifdef Q_OS_WIN
|
||||
#include <windows.h>
|
||||
#include <stdio.h>
|
||||
|
|
@ -1074,7 +1074,7 @@ bool Score::read(XmlReader& e)
|
|||
else
|
||||
e.unknown();
|
||||
}
|
||||
if (e.error() != QXmlStreamReader::NoError) {
|
||||
if (e.error() != XmlStreamReader::NoError) {
|
||||
qDebug("%s: xml read error at line %lld col %lld: %s",
|
||||
qPrintable(e.getDocName()), e.lineNumber(), e.columnNumber(),
|
||||
e.name().toUtf8().data());
|
||||
|
|
|
|||
|
|
@ -83,14 +83,14 @@ bool XmlReader::hasAttribute(const char* s) const
|
|||
|
||||
QPointF XmlReader::readPoint()
|
||||
{
|
||||
Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
|
||||
Q_ASSERT(tokenType() == XmlStreamReader::StartElement);
|
||||
#ifndef NDEBUG
|
||||
if (!attributes().hasAttribute("x")) {
|
||||
QXmlStreamAttributes map = attributes();
|
||||
XmlStreamAttributes map = attributes();
|
||||
qDebug("XmlReader::readPoint: x attribute missing: %s (%d)",
|
||||
name().toUtf8().data(), map.size());
|
||||
for (int i = 0; i < map.size(); ++i) {
|
||||
const QXmlStreamAttribute& a = map.at(i);
|
||||
const XmlStreamAttribute& a = map.at(i);
|
||||
qDebug(" attr <%s> <%s>", a.name().toUtf8().data(), a.value().toUtf8().data());
|
||||
}
|
||||
unknown();
|
||||
|
|
@ -112,7 +112,7 @@ QPointF XmlReader::readPoint()
|
|||
|
||||
QColor XmlReader::readColor()
|
||||
{
|
||||
Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
|
||||
Q_ASSERT(tokenType() == XmlStreamReader::StartElement);
|
||||
QColor c;
|
||||
c.setRed(intAttribute("r"));
|
||||
c.setGreen(intAttribute("g"));
|
||||
|
|
@ -128,7 +128,7 @@ QColor XmlReader::readColor()
|
|||
|
||||
QSizeF XmlReader::readSize()
|
||||
{
|
||||
Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
|
||||
Q_ASSERT(tokenType() == XmlStreamReader::StartElement);
|
||||
QSizeF p;
|
||||
p.setWidth(doubleAttribute("w", 0.0));
|
||||
p.setHeight(doubleAttribute("h", 0.0));
|
||||
|
|
@ -142,7 +142,7 @@ QSizeF XmlReader::readSize()
|
|||
|
||||
QRectF XmlReader::readRect()
|
||||
{
|
||||
Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
|
||||
Q_ASSERT(tokenType() == XmlStreamReader::StartElement);
|
||||
QRectF p;
|
||||
p.setX(doubleAttribute("x", 0.0));
|
||||
p.setY(doubleAttribute("y", 0.0));
|
||||
|
|
@ -158,7 +158,7 @@ QRectF XmlReader::readRect()
|
|||
|
||||
Fraction XmlReader::readFraction()
|
||||
{
|
||||
Q_ASSERT(tokenType() == QXmlStreamReader::StartElement);
|
||||
Q_ASSERT(tokenType() == XmlStreamReader::StartElement);
|
||||
int z = attribute("z", "0").toInt();
|
||||
int n = attribute("n", "0").toInt();
|
||||
skipCurrentElement();
|
||||
|
|
@ -172,7 +172,7 @@ Fraction XmlReader::readFraction()
|
|||
|
||||
void XmlReader::unknown() const
|
||||
{
|
||||
if (QXmlStreamReader::error())
|
||||
if (XmlStreamReader::error())
|
||||
qDebug("StreamReaderError: %s", qPrintable(errorString()));
|
||||
qFatal("%s: xml read error at line %lld col %lld: %s",
|
||||
qPrintable(docName), lineNumber(), columnNumber(),
|
||||
|
|
@ -625,25 +625,25 @@ void Xml::dump(int len, const unsigned char* p)
|
|||
void XmlReader::htmlToString(int level, QString* s)
|
||||
{
|
||||
*s += QString("<%1").arg(name().toString());
|
||||
for (const QXmlStreamAttribute& a : attributes())
|
||||
for (const XmlStreamAttribute& a : attributes())
|
||||
*s += QString(" %1=\"%2\"").arg(a.name().toString()).arg(a.value().toString());
|
||||
*s += ">";
|
||||
++level;
|
||||
for (;;) {
|
||||
QXmlStreamReader::TokenType t = readNext();
|
||||
XmlStreamReader::TokenType t = readNext();
|
||||
switch(t) {
|
||||
case QXmlStreamReader::StartElement:
|
||||
case XmlStreamReader::StartElement:
|
||||
htmlToString(level, s);
|
||||
break;
|
||||
case QXmlStreamReader::EndElement:
|
||||
case XmlStreamReader::EndElement:
|
||||
*s += QString("</%1>").arg(name().toString());
|
||||
--level;
|
||||
return;
|
||||
case QXmlStreamReader::Characters:
|
||||
case XmlStreamReader::Characters:
|
||||
if (!isWhitespace())
|
||||
*s += text().toString().toHtmlEscaped();
|
||||
break;
|
||||
case QXmlStreamReader::Comment:
|
||||
case XmlStreamReader::Comment:
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
@ -663,18 +663,18 @@ QString XmlReader::readXml()
|
|||
QString s;
|
||||
int level = 1;
|
||||
for (;;) {
|
||||
QXmlStreamReader::TokenType t = readNext();
|
||||
XmlStreamReader::TokenType t = readNext();
|
||||
switch(t) {
|
||||
case QXmlStreamReader::StartElement:
|
||||
case XmlStreamReader::StartElement:
|
||||
htmlToString(level, &s);
|
||||
break;
|
||||
case QXmlStreamReader::EndElement:
|
||||
case XmlStreamReader::EndElement:
|
||||
return s;
|
||||
case QXmlStreamReader::Characters:
|
||||
case XmlStreamReader::Characters:
|
||||
if (!isWhitespace())
|
||||
s += text().toString().toHtmlEscaped();
|
||||
break;
|
||||
case QXmlStreamReader::Comment:
|
||||
case XmlStreamReader::Comment:
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
#ifndef __XML_H__
|
||||
#define __XML_H__
|
||||
|
||||
#include "xmlstream.h"
|
||||
#include "thirdparty/xmlstream/xmlstream.h"
|
||||
#include "mscore.h"
|
||||
#include "spatium.h"
|
||||
#include "fraction.h"
|
||||
|
|
@ -43,7 +43,7 @@ struct SpannerValues {
|
|||
// XmlReader
|
||||
//---------------------------------------------------------
|
||||
|
||||
class XmlReader : public QXmlStreamReader {
|
||||
class XmlReader : public XmlStreamReader {
|
||||
QString docName; // used for error reporting
|
||||
|
||||
// Score read context (for read optimizations):
|
||||
|
|
@ -58,10 +58,10 @@ class XmlReader : public QXmlStreamReader {
|
|||
Interval _transpose;
|
||||
|
||||
public:
|
||||
XmlReader(QFile* f) : QXmlStreamReader(f), docName(f->fileName()) {}
|
||||
XmlReader(const QByteArray& d, const QString& s = QString()) : QXmlStreamReader(d), docName(s) {}
|
||||
XmlReader(QIODevice* d, const QString& s = QString()) : QXmlStreamReader(d), docName(s) {}
|
||||
XmlReader(const QString& d, const QString& s = QString()) : QXmlStreamReader(d), docName(s) {}
|
||||
XmlReader(QFile* f) : XmlStreamReader(f), docName(f->fileName()) {}
|
||||
XmlReader(const QByteArray& d, const QString& s = QString()) : XmlStreamReader(d), docName(s) {}
|
||||
XmlReader(QIODevice* d, const QString& s = QString()) : XmlStreamReader(d), docName(s) {}
|
||||
XmlReader(const QString& d, const QString& s = QString()) : XmlStreamReader(d), docName(s) {}
|
||||
|
||||
void unknown() const;
|
||||
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@
|
|||
|
||||
#include <assert.h>
|
||||
#include "libmscore/score.h"
|
||||
#include "libmscore/qzipreader_p.h"
|
||||
#include "thirdparty/qzip/qzipreader_p.h"
|
||||
#include "capella.h"
|
||||
|
||||
namespace Ms {
|
||||
|
|
|
|||
|
|
@ -93,7 +93,7 @@
|
|||
#include "libmscore/figuredbass.h"
|
||||
#include "libmscore/stringdata.h"
|
||||
#include "libmscore/rehearsalmark.h"
|
||||
#include "libmscore/qzipwriter_p.h"
|
||||
#include "thirdparty/qzip/qzipwriter_p.h"
|
||||
#include "libmscore/fret.h"
|
||||
#include "libmscore/tie.h"
|
||||
|
||||
|
|
@ -233,7 +233,7 @@ class SlurHandler {
|
|||
|
||||
public:
|
||||
SlurHandler();
|
||||
void doSlurStart(Chord* chord, Notations& notations, Xml& xml, bool grace = false);
|
||||
void doSlurStart(Chord* chord, Notations& notations, Xml& xml, bool grace = false);
|
||||
void doSlurStop(Chord* chord, Notations& notations, Xml& xml);
|
||||
};
|
||||
|
||||
|
|
@ -447,7 +447,7 @@ int SlurHandler::findSlur(const Slur* s) const
|
|||
|
||||
void SlurHandler::doSlurStart(Chord* chord, Notations& notations, Xml& xml, bool grace)
|
||||
{
|
||||
// slurs on grace notes are not in spanner list, therefore:
|
||||
// slurs on grace notes are not in spanner list, therefore:
|
||||
if (grace){
|
||||
foreach(Element* el, chord->el()){
|
||||
if (el->type() == Element::SLUR){
|
||||
|
|
@ -2330,7 +2330,7 @@ void ExportMusicXml::chord(Chord* chord, int staff, const QList<Lyrics*>* ll, bo
|
|||
|
||||
if (note == nl.front()) {
|
||||
if (grace){
|
||||
sh.doSlurStart(chord, notations, xml, true);
|
||||
sh.doSlurStart(chord, notations, xml, true);
|
||||
}
|
||||
else {
|
||||
tupletStartStop(chord, notations, xml);
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@
|
|||
#include "libmscore/chordline.h"
|
||||
#include "libmscore/figuredbass.h"
|
||||
#include "libmscore/fret.h"
|
||||
#include "libmscore/qzipreader_p.h"
|
||||
#include "thirdparty/qzip/qzipreader_p.h"
|
||||
#include "libmscore/stafftype.h"
|
||||
#include "libmscore/stringdata.h"
|
||||
#include "libmscore/drumset.h"
|
||||
|
|
|
|||
|
|
@ -34,8 +34,8 @@
|
|||
#include "libmscore/icon.h"
|
||||
#include "libmscore/mscore.h"
|
||||
#include "libmscore/imageStore.h"
|
||||
#include "libmscore/qzipreader_p.h"
|
||||
#include "libmscore/qzipwriter_p.h"
|
||||
#include "thirdparty/qzip/qzipreader_p.h"
|
||||
#include "thirdparty/qzip/qzipwriter_p.h"
|
||||
#include "libmscore/slur.h"
|
||||
#include "paletteBoxButton.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -22,8 +22,8 @@
|
|||
#include "libmscore/score.h"
|
||||
#include "libmscore/imageStore.h"
|
||||
#include "libmscore/xml.h"
|
||||
#include "libmscore/qzipreader_p.h"
|
||||
#include "libmscore/qzipwriter_p.h"
|
||||
#include "thirdparty/qzip/qzipreader_p.h"
|
||||
#include "thirdparty/qzip/qzipwriter_p.h"
|
||||
#include "preferences.h"
|
||||
#include "palette.h"
|
||||
#include "palettebox.h"
|
||||
|
|
|
|||
|
|
@ -39,8 +39,8 @@
|
|||
**
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef QZIPREADER_H
|
||||
#define QZIPREADER_H
|
||||
#ifndef __ZIPREADER_H__
|
||||
#define __ZIPREADER_H__
|
||||
|
||||
#ifndef QT_NO_TEXTODFWRITER
|
||||
|
||||
|
|
@ -38,8 +38,9 @@
|
|||
** $QT_END_LICENSE$
|
||||
**
|
||||
****************************************************************************/
|
||||
#ifndef QZIPWRITER_H
|
||||
#define QZIPWRITER_H
|
||||
|
||||
#ifndef __ZIPWRITER_H__
|
||||
#define __ZIPWRITER_H__
|
||||
#ifndef QT_NO_TEXTODFWRITER
|
||||
|
||||
//
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -39,7 +39,7 @@
|
|||
--
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
%parser QXmlStreamReader_Table
|
||||
%parser XmlStreamReader_Table
|
||||
|
||||
%merged_output xmlstream_p.h
|
||||
|
||||
|
|
@ -147,12 +147,12 @@
|
|||
%start document
|
||||
|
||||
/.
|
||||
template <typename T> class QXmlStreamSimpleStack {
|
||||
template <typename T> class XmlStreamSimpleStack {
|
||||
T *data;
|
||||
int tos, cap;
|
||||
public:
|
||||
inline QXmlStreamSimpleStack():data(0), tos(-1), cap(0){}
|
||||
inline ~QXmlStreamSimpleStack(){ if (data) free(data); }
|
||||
inline XmlStreamSimpleStack():data(0), tos(-1), cap(0){}
|
||||
inline ~XmlStreamSimpleStack(){ if (data) free(data); }
|
||||
|
||||
inline void reserve(int extraCapacity) {
|
||||
if (tos + extraCapacity + 1 > cap) {
|
||||
|
|
@ -176,12 +176,12 @@ public:
|
|||
};
|
||||
|
||||
|
||||
class QXmlStream
|
||||
class XmlStream
|
||||
{
|
||||
Q_DECLARE_TR_FUNCTIONS(QXmlStream)
|
||||
Q_DECLARE_TR_FUNCTIONS(XmlStream)
|
||||
};
|
||||
|
||||
class QXmlStreamPrivateTagStack {
|
||||
class XmlStreamPrivateTagStack {
|
||||
public:
|
||||
struct NamespaceDeclaration
|
||||
{
|
||||
|
|
@ -199,8 +199,8 @@ public:
|
|||
};
|
||||
|
||||
|
||||
QXmlStreamPrivateTagStack();
|
||||
QXmlStreamSimpleStack<NamespaceDeclaration> namespaceDeclarations;
|
||||
XmlStreamPrivateTagStack();
|
||||
XmlStreamSimpleStack<NamespaceDeclaration> namespaceDeclarations;
|
||||
QString tagStackStringStorage;
|
||||
int tagStackStringStorageSize;
|
||||
bool tagsDone;
|
||||
|
|
@ -224,7 +224,7 @@ public:
|
|||
return QStringRef(&tagStackStringStorage, pos, sz);
|
||||
}
|
||||
|
||||
QXmlStreamSimpleStack<Tag> tagStack;
|
||||
XmlStreamSimpleStack<Tag> tagStack;
|
||||
|
||||
|
||||
inline Tag &tagStack_pop() {
|
||||
|
|
@ -243,14 +243,14 @@ public:
|
|||
};
|
||||
|
||||
|
||||
class QXmlStreamEntityResolver;
|
||||
class XmlStreamEntityResolver;
|
||||
#ifndef QT_NO_XMLSTREAMREADER
|
||||
class QXmlStreamReaderPrivate : public QXmlStreamReader_Table, public QXmlStreamPrivateTagStack{
|
||||
QXmlStreamReader *q_ptr;
|
||||
Q_DECLARE_PUBLIC(QXmlStreamReader)
|
||||
class XmlStreamReaderPrivate : public XmlStreamReader_Table, public XmlStreamPrivateTagStack{
|
||||
XmlStreamReader *q_ptr;
|
||||
Q_DECLARE_PUBLIC(XmlStreamReader)
|
||||
public:
|
||||
QXmlStreamReaderPrivate(QXmlStreamReader *q);
|
||||
~QXmlStreamReaderPrivate();
|
||||
XmlStreamReaderPrivate(XmlStreamReader *q);
|
||||
~XmlStreamReaderPrivate();
|
||||
void init();
|
||||
|
||||
QByteArray rawReadBuffer;
|
||||
|
|
@ -259,7 +259,7 @@ public:
|
|||
qint64 nbytesread;
|
||||
QString readBuffer;
|
||||
int readBufferPos;
|
||||
QXmlStreamSimpleStack<uint> putStack;
|
||||
XmlStreamSimpleStack<uint> putStack;
|
||||
struct Entity {
|
||||
Entity(const QString& str = QString())
|
||||
:value(str), external(false), unparsed(false), literal(false),
|
||||
|
|
@ -275,10 +275,10 @@ public:
|
|||
};
|
||||
QHash<QString, Entity> entityHash;
|
||||
QHash<QString, Entity> parameterEntityHash;
|
||||
QXmlStreamSimpleStack<Entity *>entityReferenceStack;
|
||||
XmlStreamSimpleStack<Entity *>entityReferenceStack;
|
||||
inline bool referenceEntity(Entity &entity) {
|
||||
if (entity.isCurrentlyReferenced) {
|
||||
raiseWellFormedError(QXmlStream::tr("Recursive entity detected."));
|
||||
raiseWellFormedError(XmlStream::tr("Recursive entity detected."));
|
||||
return false;
|
||||
}
|
||||
entity.isCurrentlyReferenced = true;
|
||||
|
|
@ -299,8 +299,8 @@ public:
|
|||
/*!
|
||||
\sa setType()
|
||||
*/
|
||||
QXmlStreamReader::TokenType type;
|
||||
QXmlStreamReader::Error error;
|
||||
XmlStreamReader::TokenType type;
|
||||
XmlStreamReader::Error error;
|
||||
QString errorString;
|
||||
QString unresolvedEntity;
|
||||
|
||||
|
|
@ -311,7 +311,7 @@ public:
|
|||
void write(const char *);
|
||||
|
||||
|
||||
QXmlStreamAttributes attributes;
|
||||
XmlStreamAttributes attributes;
|
||||
QStringRef namespaceForPrefix(const QStringRef &prefix);
|
||||
void resolveTag();
|
||||
void resolvePublicNamespaces();
|
||||
|
|
@ -334,15 +334,15 @@ public:
|
|||
bool isCDATA;
|
||||
bool isNamespaceAttribute;
|
||||
};
|
||||
QXmlStreamSimpleStack<DtdAttribute> dtdAttributes;
|
||||
XmlStreamSimpleStack<DtdAttribute> dtdAttributes;
|
||||
struct NotationDeclaration {
|
||||
QStringRef name;
|
||||
QStringRef publicId;
|
||||
QStringRef systemId;
|
||||
};
|
||||
QXmlStreamSimpleStack<NotationDeclaration> notationDeclarations;
|
||||
QXmlStreamNotationDeclarations publicNotationDeclarations;
|
||||
QXmlStreamNamespaceDeclarations publicNamespaceDeclarations;
|
||||
XmlStreamSimpleStack<NotationDeclaration> notationDeclarations;
|
||||
XmlStreamNotationDeclarations publicNotationDeclarations;
|
||||
XmlStreamNamespaceDeclarations publicNamespaceDeclarations;
|
||||
|
||||
struct EntityDeclaration {
|
||||
QStringRef name;
|
||||
|
|
@ -361,8 +361,8 @@ public:
|
|||
parameter = external = false;
|
||||
}
|
||||
};
|
||||
QXmlStreamSimpleStack<EntityDeclaration> entityDeclarations;
|
||||
QXmlStreamEntityDeclarations publicEntityDeclarations;
|
||||
XmlStreamSimpleStack<EntityDeclaration> entityDeclarations;
|
||||
XmlStreamEntityDeclarations publicEntityDeclarations;
|
||||
|
||||
QStringRef text;
|
||||
|
||||
|
|
@ -421,7 +421,7 @@ public:
|
|||
Value key;
|
||||
Value value;
|
||||
};
|
||||
QXmlStreamSimpleStack<Attribute> attributeStack;
|
||||
XmlStreamSimpleStack<Attribute> attributeStack;
|
||||
|
||||
inline QStringRef symString(int index) {
|
||||
const Value &symbol = sym(index);
|
||||
|
|
@ -478,7 +478,7 @@ public:
|
|||
|
||||
QString resolveUndeclaredEntity(const QString &name);
|
||||
void parseEntity(const QString &value);
|
||||
QXmlStreamReaderPrivate *entityParser;
|
||||
XmlStreamReaderPrivate *entityParser;
|
||||
|
||||
bool scanAfterLangleBang();
|
||||
bool scanPublicOrSystem();
|
||||
|
|
@ -499,10 +499,10 @@ public:
|
|||
bool parse();
|
||||
inline void consumeRule(int);
|
||||
|
||||
void raiseError(QXmlStreamReader::Error error, const QString& message = QString());
|
||||
void raiseError(XmlStreamReader::Error error, const QString& message = QString());
|
||||
void raiseWellFormedError(const QString &message);
|
||||
|
||||
QXmlStreamEntityResolver *entityResolver;
|
||||
XmlStreamEntityResolver *entityResolver;
|
||||
|
||||
private:
|
||||
/*! \internal
|
||||
|
|
@ -510,19 +510,19 @@ private:
|
|||
|
||||
This prevents errors from being ignored.
|
||||
*/
|
||||
inline void setType(const QXmlStreamReader::TokenType t)
|
||||
inline void setType(const XmlStreamReader::TokenType t)
|
||||
{
|
||||
if(type != QXmlStreamReader::Invalid)
|
||||
if(type != XmlStreamReader::Invalid)
|
||||
type = t;
|
||||
}
|
||||
};
|
||||
|
||||
bool QXmlStreamReaderPrivate::parse()
|
||||
bool XmlStreamReaderPrivate::parse()
|
||||
{
|
||||
// cleanup currently reported token
|
||||
|
||||
switch (type) {
|
||||
case QXmlStreamReader::StartElement:
|
||||
case XmlStreamReader::StartElement:
|
||||
name.clear();
|
||||
prefix.clear();
|
||||
qualifiedName.clear();
|
||||
|
|
@ -532,7 +532,7 @@ bool QXmlStreamReaderPrivate::parse()
|
|||
if (attributes.size())
|
||||
attributes.resize(0);
|
||||
if (isEmptyElement) {
|
||||
setType(QXmlStreamReader::EndElement);
|
||||
setType(XmlStreamReader::EndElement);
|
||||
Tag &tag = tagStack_pop();
|
||||
namespaceUri = tag.namespaceDeclaration.namespaceUri;
|
||||
name = tag.name;
|
||||
|
|
@ -542,47 +542,47 @@ bool QXmlStreamReaderPrivate::parse()
|
|||
}
|
||||
clearTextBuffer();
|
||||
break;
|
||||
case QXmlStreamReader::EndElement:
|
||||
case XmlStreamReader::EndElement:
|
||||
name.clear();
|
||||
prefix.clear();
|
||||
qualifiedName.clear();
|
||||
namespaceUri.clear();
|
||||
clearTextBuffer();
|
||||
break;
|
||||
case QXmlStreamReader::DTD:
|
||||
case XmlStreamReader::DTD:
|
||||
publicNotationDeclarations.clear();
|
||||
publicEntityDeclarations.clear();
|
||||
dtdName.clear();
|
||||
dtdPublicId.clear();
|
||||
dtdSystemId.clear();
|
||||
// fall through
|
||||
case QXmlStreamReader::Comment:
|
||||
case QXmlStreamReader::Characters:
|
||||
case XmlStreamReader::Comment:
|
||||
case XmlStreamReader::Characters:
|
||||
isCDATA = false;
|
||||
isWhitespace = true;
|
||||
text.clear();
|
||||
clearTextBuffer();
|
||||
break;
|
||||
case QXmlStreamReader::EntityReference:
|
||||
case XmlStreamReader::EntityReference:
|
||||
text.clear();
|
||||
name.clear();
|
||||
clearTextBuffer();
|
||||
break;
|
||||
case QXmlStreamReader::ProcessingInstruction:
|
||||
case XmlStreamReader::ProcessingInstruction:
|
||||
processingInstructionTarget.clear();
|
||||
processingInstructionData.clear();
|
||||
clearTextBuffer();
|
||||
break;
|
||||
case QXmlStreamReader::NoToken:
|
||||
case QXmlStreamReader::Invalid:
|
||||
case XmlStreamReader::NoToken:
|
||||
case XmlStreamReader::Invalid:
|
||||
break;
|
||||
case QXmlStreamReader::StartDocument:
|
||||
case XmlStreamReader::StartDocument:
|
||||
lockEncoding = true;
|
||||
documentVersion.clear();
|
||||
documentEncoding.clear();
|
||||
#ifndef QT_NO_TEXTCODEC
|
||||
if (decoder->hasFailure()) {
|
||||
raiseWellFormedError(QXmlStream::tr("Encountered incorrectly encoded content."));
|
||||
raiseWellFormedError(XmlStream::tr("Encountered incorrectly encoded content."));
|
||||
readBuffer.clear();
|
||||
return false;
|
||||
}
|
||||
|
|
@ -593,7 +593,7 @@ bool QXmlStreamReaderPrivate::parse()
|
|||
;
|
||||
}
|
||||
|
||||
setType(QXmlStreamReader::NoToken);
|
||||
setType(XmlStreamReader::NoToken);
|
||||
|
||||
|
||||
// the main parse loop
|
||||
|
|
@ -637,7 +637,7 @@ bool QXmlStreamReaderPrivate::parse()
|
|||
if (!tagsDone && !inParseEntity) {
|
||||
int a = t_action(act, token);
|
||||
if (a < 0) {
|
||||
raiseError(QXmlStreamReader::PrematureEndOfDocumentError);
|
||||
raiseError(XmlStreamReader::PrematureEndOfDocumentError);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
@ -798,18 +798,18 @@ bool QXmlStreamReaderPrivate::parse()
|
|||
document ::= PARSE_ENTITY content;
|
||||
/.
|
||||
case $rule_number:
|
||||
setType(QXmlStreamReader::EndDocument);
|
||||
setType(XmlStreamReader::EndDocument);
|
||||
break;
|
||||
./
|
||||
|
||||
document ::= prolog;
|
||||
/.
|
||||
case $rule_number:
|
||||
if (type != QXmlStreamReader::Invalid) {
|
||||
if (type != XmlStreamReader::Invalid) {
|
||||
if (hasSeenTag || inParseEntity) {
|
||||
setType(QXmlStreamReader::EndDocument);
|
||||
setType(XmlStreamReader::EndDocument);
|
||||
} else {
|
||||
raiseError(QXmlStreamReader::NotWellFormedError, QXmlStream::tr("Start tag expected."));
|
||||
raiseError(XmlStreamReader::NotWellFormedError, XmlStream::tr("Start tag expected."));
|
||||
// reset the parser
|
||||
tos = 0;
|
||||
state_stack[tos++] = 0;
|
||||
|
|
@ -852,7 +852,7 @@ xml_decl_start ::= XML;
|
|||
xml_decl ::= xml_decl_start VERSION space_opt EQ space_opt literal attribute_list_opt QUESTIONMARK RANGLE;
|
||||
/.
|
||||
case $rule_number:
|
||||
setType(QXmlStreamReader::StartDocument);
|
||||
setType(XmlStreamReader::StartDocument);
|
||||
documentVersion = symString(6);
|
||||
startDocument();
|
||||
break;
|
||||
|
|
@ -902,7 +902,7 @@ doctype_decl ::= doctype_decl_start external_id space_opt markup space_opt RANGL
|
|||
doctype_decl ::= doctype_decl_start external_id space_opt RANGLE;
|
||||
/.
|
||||
case $rule_number:
|
||||
setType(QXmlStreamReader::DTD);
|
||||
setType(XmlStreamReader::DTD);
|
||||
text = &textBuffer;
|
||||
break;
|
||||
./
|
||||
|
|
@ -1136,7 +1136,7 @@ entity_decl ::= entity_decl_external NDATA name space_opt RANGLE;
|
|||
EntityDeclaration &entityDeclaration = entityDeclarations.top();
|
||||
entityDeclaration.notationName = symString(3);
|
||||
if (entityDeclaration.parameter)
|
||||
raiseWellFormedError(QXmlStream::tr("NDATA in parameter entity declaration."));
|
||||
raiseWellFormedError(XmlStream::tr("NDATA in parameter entity declaration."));
|
||||
}
|
||||
//fall through
|
||||
./
|
||||
|
|
@ -1170,18 +1170,18 @@ entity_decl ::= entity_decl_start entity_value space_opt RANGLE;
|
|||
processing_instruction ::= LANGLE QUESTIONMARK name space;
|
||||
/.
|
||||
case $rule_number: {
|
||||
setType(QXmlStreamReader::ProcessingInstruction);
|
||||
setType(XmlStreamReader::ProcessingInstruction);
|
||||
int pos = sym(4).pos + sym(4).len;
|
||||
processingInstructionTarget = symString(3);
|
||||
if (scanUntil("?>")) {
|
||||
processingInstructionData = QStringRef(&textBuffer, pos, textBuffer.size() - pos - 2);
|
||||
const QString piTarget(processingInstructionTarget.toString());
|
||||
if (!piTarget.compare(QLatin1String("xml"), Qt::CaseInsensitive)) {
|
||||
raiseWellFormedError(QXmlStream::tr("XML declaration not at start of document."));
|
||||
raiseWellFormedError(XmlStream::tr("XML declaration not at start of document."));
|
||||
}
|
||||
else if(!QXmlUtils::isNCName(piTarget))
|
||||
raiseWellFormedError(QXmlStream::tr("%1 is an invalid processing instruction name.").arg(piTarget));
|
||||
} else if (type != QXmlStreamReader::Invalid){
|
||||
raiseWellFormedError(XmlStream::tr("%1 is an invalid processing instruction name.").arg(piTarget));
|
||||
} else if (type != XmlStreamReader::Invalid){
|
||||
resume($rule_number);
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1191,10 +1191,10 @@ processing_instruction ::= LANGLE QUESTIONMARK name space;
|
|||
processing_instruction ::= LANGLE QUESTIONMARK name QUESTIONMARK RANGLE;
|
||||
/.
|
||||
case $rule_number:
|
||||
setType(QXmlStreamReader::ProcessingInstruction);
|
||||
setType(XmlStreamReader::ProcessingInstruction);
|
||||
processingInstructionTarget = symString(3);
|
||||
if (!processingInstructionTarget.toString().compare(QLatin1String("xml"), Qt::CaseInsensitive))
|
||||
raiseWellFormedError(QXmlStream::tr("Invalid processing instruction name."));
|
||||
raiseWellFormedError(XmlStream::tr("Invalid processing instruction name."));
|
||||
break;
|
||||
./
|
||||
|
||||
|
|
@ -1222,7 +1222,7 @@ comment_start ::= langle_bang DASH DASH;
|
|||
comment ::= comment_start RANGLE;
|
||||
/.
|
||||
case $rule_number: {
|
||||
setType(QXmlStreamReader::Comment);
|
||||
setType(XmlStreamReader::Comment);
|
||||
int pos = sym(1).pos + 4;
|
||||
text = QStringRef(&textBuffer, pos, textBuffer.size() - pos - 3);
|
||||
} break;
|
||||
|
|
@ -1232,7 +1232,7 @@ comment ::= comment_start RANGLE;
|
|||
cdata ::= langle_bang CDATA_START;
|
||||
/.
|
||||
case $rule_number: {
|
||||
setType(QXmlStreamReader::Characters);
|
||||
setType(XmlStreamReader::Characters);
|
||||
isCDATA = true;
|
||||
isWhitespace = false;
|
||||
int pos = sym(2).pos;
|
||||
|
|
@ -1320,7 +1320,7 @@ character_content ::= content_char_list %prec SHIFT_THERE;
|
|||
/.
|
||||
case $rule_number:
|
||||
if (!textBuffer.isEmpty()) {
|
||||
setType(QXmlStreamReader::Characters);
|
||||
setType(XmlStreamReader::Characters);
|
||||
text = &textBuffer;
|
||||
}
|
||||
break;
|
||||
|
|
@ -1391,7 +1391,7 @@ public_literal ::= literal;
|
|||
/.
|
||||
case $rule_number: {
|
||||
if (!QXmlUtils::isPublicID(symString(1).toString())) {
|
||||
raiseWellFormedError(QXmlStream::tr("%1 is an invalid PUBLIC identifier.").arg(symString(1).toString()));
|
||||
raiseWellFormedError(XmlStream::tr("%1 is an invalid PUBLIC identifier.").arg(symString(1).toString()));
|
||||
resume($rule_number);
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1493,7 +1493,7 @@ attribute ::= qname space_opt EQ space_opt attribute_value;
|
|||
const QStringRef ns(symString(5));
|
||||
if(ns == QLatin1String("http://www.w3.org/2000/xmlns/") ||
|
||||
ns == QLatin1String("http://www.w3.org/XML/1998/namespace"))
|
||||
raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));
|
||||
raiseWellFormedError(XmlStream::tr("Illegal namespace declaration."));
|
||||
else
|
||||
namespaceDeclaration.namespaceUri = addToStringStorage(ns);
|
||||
} else {
|
||||
|
|
@ -1546,7 +1546,7 @@ attribute ::= qname space_opt EQ space_opt attribute_value;
|
|||
|| namespaceUri == QLatin1String("http://www.w3.org/2000/xmlns/")
|
||||
|| namespaceUri.isEmpty()
|
||||
|| namespacePrefix == QLatin1String("xmlns"))
|
||||
raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));
|
||||
raiseWellFormedError(XmlStream::tr("Illegal namespace declaration."));
|
||||
|
||||
namespaceDeclaration.prefix = addToStringStorage(namespacePrefix);
|
||||
namespaceDeclaration.namespaceUri = addToStringStorage(namespaceUri);
|
||||
|
|
@ -1569,7 +1569,7 @@ stag_start ::= LANGLE qname;
|
|||
name = tag.name = addToStringStorage(symString(2));
|
||||
qualifiedName = tag.qualifiedName = addToStringStorage(symName(2));
|
||||
if ((!prefix.isEmpty() && !QXmlUtils::isNCName(prefix)) || !QXmlUtils::isNCName(name))
|
||||
raiseWellFormedError(QXmlStream::tr("Invalid XML name."));
|
||||
raiseWellFormedError(XmlStream::tr("Invalid XML name."));
|
||||
} break;
|
||||
./
|
||||
|
||||
|
|
@ -1585,10 +1585,10 @@ empty_element_tag ::= stag_start attribute_list_opt SLASH RANGLE;
|
|||
stag ::= stag_start attribute_list_opt RANGLE;
|
||||
/.
|
||||
case $rule_number:
|
||||
setType(QXmlStreamReader::StartElement);
|
||||
setType(XmlStreamReader::StartElement);
|
||||
resolveTag();
|
||||
if (tagStack.size() == 1 && hasSeenTag && !inParseEntity)
|
||||
raiseWellFormedError(QXmlStream::tr("Extra content at end of document."));
|
||||
raiseWellFormedError(XmlStream::tr("Extra content at end of document."));
|
||||
hasSeenTag = true;
|
||||
break;
|
||||
./
|
||||
|
|
@ -1597,14 +1597,14 @@ stag ::= stag_start attribute_list_opt RANGLE;
|
|||
etag ::= LANGLE SLASH qname space_opt RANGLE;
|
||||
/.
|
||||
case $rule_number: {
|
||||
setType(QXmlStreamReader::EndElement);
|
||||
setType(XmlStreamReader::EndElement);
|
||||
Tag &tag = tagStack_pop();
|
||||
|
||||
namespaceUri = tag.namespaceDeclaration.namespaceUri;
|
||||
name = tag.name;
|
||||
qualifiedName = tag.qualifiedName;
|
||||
if (qualifiedName != symName(3))
|
||||
raiseWellFormedError(QXmlStream::tr("Opening and ending tag mismatch."));
|
||||
raiseWellFormedError(XmlStream::tr("Opening and ending tag mismatch."));
|
||||
} break;
|
||||
./
|
||||
|
||||
|
|
@ -1613,10 +1613,10 @@ unresolved_entity ::= UNRESOLVED_ENTITY;
|
|||
/.
|
||||
case $rule_number:
|
||||
if (entitiesMustBeDeclared()) {
|
||||
raiseWellFormedError(QXmlStream::tr("Entity '%1' not declared.").arg(unresolvedEntity));
|
||||
raiseWellFormedError(XmlStream::tr("Entity '%1' not declared.").arg(unresolvedEntity));
|
||||
break;
|
||||
}
|
||||
setType(QXmlStreamReader::EntityReference);
|
||||
setType(XmlStreamReader::EntityReference);
|
||||
name = &unresolvedEntity;
|
||||
break;
|
||||
./
|
||||
|
|
@ -1629,7 +1629,7 @@ entity_ref ::= AMPERSAND name SEMICOLON;
|
|||
if (entityHash.contains(reference)) {
|
||||
Entity &entity = entityHash[reference];
|
||||
if (entity.unparsed) {
|
||||
raiseWellFormedError(QXmlStream::tr("Reference to unparsed entity '%1'.").arg(reference));
|
||||
raiseWellFormedError(XmlStream::tr("Reference to unparsed entity '%1'.").arg(reference));
|
||||
} else {
|
||||
if (!entity.hasBeenParsed) {
|
||||
parseEntity(entity.value);
|
||||
|
|
@ -1680,7 +1680,7 @@ pereference ::= PERCENT name SEMICOLON;
|
|||
clearSym();
|
||||
}
|
||||
} else if (entitiesMustBeDeclared()) {
|
||||
raiseWellFormedError(QXmlStream::tr("Entity '%1' not declared.").arg(symString(2).toString()));
|
||||
raiseWellFormedError(XmlStream::tr("Entity '%1' not declared.").arg(symString(2).toString()));
|
||||
}
|
||||
} break;
|
||||
./
|
||||
|
|
@ -1702,7 +1702,7 @@ entity_ref_in_attribute_value ::= AMPERSAND name SEMICOLON;
|
|||
if (entityHash.contains(reference)) {
|
||||
Entity &entity = entityHash[reference];
|
||||
if (entity.unparsed || entity.value.isNull()) {
|
||||
raiseWellFormedError(QXmlStream::tr("Reference to external entity '%1' in attribute value.").arg(reference));
|
||||
raiseWellFormedError(XmlStream::tr("Reference to external entity '%1' in attribute value.").arg(reference));
|
||||
break;
|
||||
}
|
||||
if (!entity.hasBeenParsed) {
|
||||
|
|
@ -1728,7 +1728,7 @@ entity_ref_in_attribute_value ::= AMPERSAND name SEMICOLON;
|
|||
}
|
||||
}
|
||||
if (entitiesMustBeDeclared()) {
|
||||
raiseWellFormedError(QXmlStream::tr("Entity '%1' not declared.").arg(reference));
|
||||
raiseWellFormedError(XmlStream::tr("Entity '%1' not declared.").arg(reference));
|
||||
}
|
||||
} break;
|
||||
./
|
||||
|
|
@ -1745,7 +1745,7 @@ char_ref ::= AMPERSAND HASH char_ref_value SEMICOLON;
|
|||
textBuffer.chop(3 + sym(3).len);
|
||||
clearSym();
|
||||
} else {
|
||||
raiseWellFormedError(QXmlStream::tr("Invalid character reference."));
|
||||
raiseWellFormedError(XmlStream::tr("Invalid character reference."));
|
||||
}
|
||||
} break;
|
||||
./
|
||||
|
|
@ -1842,7 +1842,7 @@ nmtoken ::= COLON;
|
|||
;
|
||||
} // switch
|
||||
act = state_stack[tos] = nt_action (act, lhs[r] - TERMINAL_COUNT);
|
||||
if (type != QXmlStreamReader::NoToken)
|
||||
if (type != XmlStreamReader::NoToken)
|
||||
return true;
|
||||
} else {
|
||||
parseError();
|
||||
|
|
@ -39,29 +39,26 @@
|
|||
**
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef QXMLSTREAM_H
|
||||
#define QXMLSTREAM_H
|
||||
#ifndef __XMLSTREAM_H__
|
||||
#define __XMLSTREAM_H__
|
||||
|
||||
#include <QtCore/qiodevice.h>
|
||||
|
||||
#ifndef QT_NO_XMLSTREAM
|
||||
|
||||
#include <QtCore/qstring.h>
|
||||
#include <QtCore/qvector.h>
|
||||
#include <QtCore/qscopedpointer.h>
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
|
||||
class Q_CORE_EXPORT QXmlStreamStringRef {
|
||||
class Q_CORE_EXPORT XmlStreamStringRef {
|
||||
QString m_string;
|
||||
int m_position, m_size;
|
||||
public:
|
||||
inline QXmlStreamStringRef():m_position(0), m_size(0){}
|
||||
inline QXmlStreamStringRef(const QStringRef &aString)
|
||||
inline XmlStreamStringRef():m_position(0), m_size(0){}
|
||||
inline XmlStreamStringRef(const QStringRef &aString)
|
||||
:m_string(aString.string()?*aString.string():QString()), m_position(aString.position()), m_size(aString.size()){}
|
||||
inline QXmlStreamStringRef(const QString &aString):m_string(aString), m_position(0), m_size(aString.size()){}
|
||||
inline ~QXmlStreamStringRef(){}
|
||||
inline XmlStreamStringRef(const QString &aString):m_string(aString), m_position(0), m_size(aString.size()){}
|
||||
inline ~XmlStreamStringRef(){}
|
||||
inline void clear() { m_string.clear(); m_position = m_size = 0; }
|
||||
inline operator QStringRef() const { return QStringRef(&m_string, m_position, m_size); }
|
||||
inline const QString *string() const { return &m_string; }
|
||||
|
|
@ -70,21 +67,21 @@ public:
|
|||
};
|
||||
|
||||
|
||||
class QXmlStreamReaderPrivate;
|
||||
class QXmlStreamAttributes;
|
||||
class Q_CORE_EXPORT QXmlStreamAttribute {
|
||||
QXmlStreamStringRef m_name, m_namespaceUri, m_qualifiedName, m_value;
|
||||
class XmlStreamReaderPrivate;
|
||||
class XmlStreamAttributes;
|
||||
class Q_CORE_EXPORT XmlStreamAttribute {
|
||||
XmlStreamStringRef m_name, m_namespaceUri, m_qualifiedName, m_value;
|
||||
void *reserved;
|
||||
uint m_isDefault : 1;
|
||||
friend class QXmlStreamReaderPrivate;
|
||||
friend class QXmlStreamAttributes;
|
||||
friend class XmlStreamReaderPrivate;
|
||||
friend class XmlStreamAttributes;
|
||||
public:
|
||||
QXmlStreamAttribute();
|
||||
QXmlStreamAttribute(const QString &qualifiedName, const QString &value);
|
||||
QXmlStreamAttribute(const QString &namespaceUri, const QString &name, const QString &value);
|
||||
QXmlStreamAttribute(const QXmlStreamAttribute &);
|
||||
QXmlStreamAttribute& operator=(const QXmlStreamAttribute &);
|
||||
~QXmlStreamAttribute();
|
||||
XmlStreamAttribute();
|
||||
XmlStreamAttribute(const QString &qualifiedName, const QString &value);
|
||||
XmlStreamAttribute(const QString &namespaceUri, const QString &name, const QString &value);
|
||||
XmlStreamAttribute(const XmlStreamAttribute &);
|
||||
XmlStreamAttribute& operator=(const XmlStreamAttribute &);
|
||||
~XmlStreamAttribute();
|
||||
inline QStringRef namespaceUri() const { return m_namespaceUri; }
|
||||
inline QStringRef name() const { return m_name; }
|
||||
inline QStringRef qualifiedName() const { return m_qualifiedName; }
|
||||
|
|
@ -95,21 +92,21 @@ public:
|
|||
}
|
||||
inline QStringRef value() const { return m_value; }
|
||||
inline bool isDefault() const { return m_isDefault; }
|
||||
inline bool operator==(const QXmlStreamAttribute &other) const {
|
||||
inline bool operator==(const XmlStreamAttribute &other) const {
|
||||
return (value() == other.value()
|
||||
&& (namespaceUri().isNull() ? (qualifiedName() == other.qualifiedName())
|
||||
: (namespaceUri() == other.namespaceUri() && name() == other.name())));
|
||||
}
|
||||
inline bool operator!=(const QXmlStreamAttribute &other) const
|
||||
inline bool operator!=(const XmlStreamAttribute &other) const
|
||||
{ return !operator==(other); }
|
||||
};
|
||||
|
||||
Q_DECLARE_TYPEINFO(QXmlStreamAttribute, Q_MOVABLE_TYPE);
|
||||
Q_DECLARE_TYPEINFO(XmlStreamAttribute, Q_MOVABLE_TYPE);
|
||||
|
||||
class Q_CORE_EXPORT QXmlStreamAttributes : public QVector<QXmlStreamAttribute>
|
||||
class Q_CORE_EXPORT XmlStreamAttributes : public QVector<XmlStreamAttribute>
|
||||
{
|
||||
public:
|
||||
inline QXmlStreamAttributes() {}
|
||||
inline XmlStreamAttributes() {}
|
||||
QStringRef value(const QString &namespaceUri, const QString &name) const;
|
||||
QStringRef value(const QString &namespaceUri, QLatin1String name) const;
|
||||
QStringRef value(QLatin1String namespaceUri, QLatin1String name) const;
|
||||
|
|
@ -134,100 +131,99 @@ public:
|
|||
}
|
||||
|
||||
#if !defined(Q_NO_USING_KEYWORD)
|
||||
using QVector<QXmlStreamAttribute>::append;
|
||||
using QVector<XmlStreamAttribute>::append;
|
||||
#else
|
||||
inline void append(const QXmlStreamAttribute &attribute)
|
||||
{ QVector<QXmlStreamAttribute>::append(attribute); }
|
||||
inline void append(const XmlStreamAttribute &attribute)
|
||||
{ QVector<XmlStreamAttribute>::append(attribute); }
|
||||
#endif
|
||||
};
|
||||
|
||||
class Q_CORE_EXPORT QXmlStreamNamespaceDeclaration {
|
||||
QXmlStreamStringRef m_prefix, m_namespaceUri;
|
||||
class Q_CORE_EXPORT XmlStreamNamespaceDeclaration {
|
||||
XmlStreamStringRef m_prefix, m_namespaceUri;
|
||||
void *reserved;
|
||||
|
||||
friend class QXmlStreamReaderPrivate;
|
||||
friend class XmlStreamReaderPrivate;
|
||||
public:
|
||||
QXmlStreamNamespaceDeclaration();
|
||||
QXmlStreamNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &);
|
||||
QXmlStreamNamespaceDeclaration(const QString &prefix, const QString &namespaceUri);
|
||||
~QXmlStreamNamespaceDeclaration();
|
||||
QXmlStreamNamespaceDeclaration& operator=(const QXmlStreamNamespaceDeclaration &);
|
||||
XmlStreamNamespaceDeclaration();
|
||||
XmlStreamNamespaceDeclaration(const XmlStreamNamespaceDeclaration &);
|
||||
XmlStreamNamespaceDeclaration(const QString &prefix, const QString &namespaceUri);
|
||||
~XmlStreamNamespaceDeclaration();
|
||||
XmlStreamNamespaceDeclaration& operator=(const XmlStreamNamespaceDeclaration &);
|
||||
inline QStringRef prefix() const { return m_prefix; }
|
||||
inline QStringRef namespaceUri() const { return m_namespaceUri; }
|
||||
inline bool operator==(const QXmlStreamNamespaceDeclaration &other) const {
|
||||
inline bool operator==(const XmlStreamNamespaceDeclaration &other) const {
|
||||
return (prefix() == other.prefix() && namespaceUri() == other.namespaceUri());
|
||||
}
|
||||
inline bool operator!=(const QXmlStreamNamespaceDeclaration &other) const
|
||||
inline bool operator!=(const XmlStreamNamespaceDeclaration &other) const
|
||||
{ return !operator==(other); }
|
||||
};
|
||||
|
||||
Q_DECLARE_TYPEINFO(QXmlStreamNamespaceDeclaration, Q_MOVABLE_TYPE);
|
||||
typedef QVector<QXmlStreamNamespaceDeclaration> QXmlStreamNamespaceDeclarations;
|
||||
Q_DECLARE_TYPEINFO(XmlStreamNamespaceDeclaration, Q_MOVABLE_TYPE);
|
||||
typedef QVector<XmlStreamNamespaceDeclaration> XmlStreamNamespaceDeclarations;
|
||||
|
||||
class Q_CORE_EXPORT QXmlStreamNotationDeclaration {
|
||||
QXmlStreamStringRef m_name, m_systemId, m_publicId;
|
||||
class Q_CORE_EXPORT XmlStreamNotationDeclaration {
|
||||
XmlStreamStringRef m_name, m_systemId, m_publicId;
|
||||
void *reserved;
|
||||
|
||||
friend class QXmlStreamReaderPrivate;
|
||||
friend class XmlStreamReaderPrivate;
|
||||
public:
|
||||
QXmlStreamNotationDeclaration();
|
||||
~QXmlStreamNotationDeclaration();
|
||||
QXmlStreamNotationDeclaration(const QXmlStreamNotationDeclaration &);
|
||||
QXmlStreamNotationDeclaration& operator=(const QXmlStreamNotationDeclaration &);
|
||||
XmlStreamNotationDeclaration();
|
||||
~XmlStreamNotationDeclaration();
|
||||
XmlStreamNotationDeclaration(const XmlStreamNotationDeclaration &);
|
||||
XmlStreamNotationDeclaration& operator=(const XmlStreamNotationDeclaration &);
|
||||
inline QStringRef name() const { return m_name; }
|
||||
inline QStringRef systemId() const { return m_systemId; }
|
||||
inline QStringRef publicId() const { return m_publicId; }
|
||||
inline bool operator==(const QXmlStreamNotationDeclaration &other) const {
|
||||
inline bool operator==(const XmlStreamNotationDeclaration &other) const {
|
||||
return (name() == other.name() && systemId() == other.systemId()
|
||||
&& publicId() == other.publicId());
|
||||
}
|
||||
inline bool operator!=(const QXmlStreamNotationDeclaration &other) const
|
||||
inline bool operator!=(const XmlStreamNotationDeclaration &other) const
|
||||
{ return !operator==(other); }
|
||||
};
|
||||
|
||||
Q_DECLARE_TYPEINFO(QXmlStreamNotationDeclaration, Q_MOVABLE_TYPE);
|
||||
typedef QVector<QXmlStreamNotationDeclaration> QXmlStreamNotationDeclarations;
|
||||
Q_DECLARE_TYPEINFO(XmlStreamNotationDeclaration, Q_MOVABLE_TYPE);
|
||||
typedef QVector<XmlStreamNotationDeclaration> XmlStreamNotationDeclarations;
|
||||
|
||||
class Q_CORE_EXPORT QXmlStreamEntityDeclaration {
|
||||
QXmlStreamStringRef m_name, m_notationName, m_systemId, m_publicId, m_value;
|
||||
class Q_CORE_EXPORT XmlStreamEntityDeclaration {
|
||||
XmlStreamStringRef m_name, m_notationName, m_systemId, m_publicId, m_value;
|
||||
void *reserved;
|
||||
|
||||
friend class QXmlStreamReaderPrivate;
|
||||
friend class XmlStreamReaderPrivate;
|
||||
public:
|
||||
QXmlStreamEntityDeclaration();
|
||||
~QXmlStreamEntityDeclaration();
|
||||
QXmlStreamEntityDeclaration(const QXmlStreamEntityDeclaration &);
|
||||
QXmlStreamEntityDeclaration& operator=(const QXmlStreamEntityDeclaration &);
|
||||
XmlStreamEntityDeclaration();
|
||||
~XmlStreamEntityDeclaration();
|
||||
XmlStreamEntityDeclaration(const XmlStreamEntityDeclaration &);
|
||||
XmlStreamEntityDeclaration& operator=(const XmlStreamEntityDeclaration &);
|
||||
inline QStringRef name() const { return m_name; }
|
||||
inline QStringRef notationName() const { return m_notationName; }
|
||||
inline QStringRef systemId() const { return m_systemId; }
|
||||
inline QStringRef publicId() const { return m_publicId; }
|
||||
inline QStringRef value() const { return m_value; }
|
||||
inline bool operator==(const QXmlStreamEntityDeclaration &other) const {
|
||||
inline bool operator==(const XmlStreamEntityDeclaration &other) const {
|
||||
return (name() == other.name()
|
||||
&& notationName() == other.notationName()
|
||||
&& systemId() == other.systemId()
|
||||
&& publicId() == other.publicId()
|
||||
&& value() == other.value());
|
||||
}
|
||||
inline bool operator!=(const QXmlStreamEntityDeclaration &other) const
|
||||
inline bool operator!=(const XmlStreamEntityDeclaration &other) const
|
||||
{ return !operator==(other); }
|
||||
};
|
||||
|
||||
Q_DECLARE_TYPEINFO(QXmlStreamEntityDeclaration, Q_MOVABLE_TYPE);
|
||||
typedef QVector<QXmlStreamEntityDeclaration> QXmlStreamEntityDeclarations;
|
||||
Q_DECLARE_TYPEINFO(XmlStreamEntityDeclaration, Q_MOVABLE_TYPE);
|
||||
typedef QVector<XmlStreamEntityDeclaration> XmlStreamEntityDeclarations;
|
||||
|
||||
|
||||
class Q_CORE_EXPORT QXmlStreamEntityResolver
|
||||
class Q_CORE_EXPORT XmlStreamEntityResolver
|
||||
{
|
||||
public:
|
||||
virtual ~QXmlStreamEntityResolver();
|
||||
virtual ~XmlStreamEntityResolver();
|
||||
virtual QString resolveEntity(const QString& publicId, const QString& systemId);
|
||||
virtual QString resolveUndeclaredEntity(const QString &name);
|
||||
};
|
||||
|
||||
#ifndef QT_NO_XMLSTREAMREADER
|
||||
class Q_CORE_EXPORT QXmlStreamReader {
|
||||
class XmlStreamReader {
|
||||
QDOC_PROPERTY(bool namespaceProcessing READ namespaceProcessing WRITE setNamespaceProcessing)
|
||||
public:
|
||||
enum TokenType {
|
||||
|
|
@ -244,13 +240,12 @@ public:
|
|||
ProcessingInstruction
|
||||
};
|
||||
|
||||
|
||||
QXmlStreamReader();
|
||||
explicit QXmlStreamReader(QIODevice *device);
|
||||
explicit QXmlStreamReader(const QByteArray &data);
|
||||
explicit QXmlStreamReader(const QString &data);
|
||||
explicit QXmlStreamReader(const char * data);
|
||||
~QXmlStreamReader();
|
||||
XmlStreamReader();
|
||||
explicit XmlStreamReader(QIODevice *device);
|
||||
explicit XmlStreamReader(const QByteArray &data);
|
||||
explicit XmlStreamReader(const QString &data);
|
||||
explicit XmlStreamReader(const char * data);
|
||||
~XmlStreamReader();
|
||||
|
||||
void setDevice(QIODevice *device);
|
||||
QIODevice *device() const;
|
||||
|
|
@ -292,7 +287,7 @@ public:
|
|||
qint64 columnNumber() const;
|
||||
qint64 characterOffset() const;
|
||||
|
||||
QXmlStreamAttributes attributes() const;
|
||||
XmlStreamAttributes attributes() const;
|
||||
|
||||
enum ReadElementTextBehaviour {
|
||||
ErrorOnUnexpectedElement,
|
||||
|
|
@ -311,11 +306,11 @@ public:
|
|||
|
||||
QStringRef text() const;
|
||||
|
||||
QXmlStreamNamespaceDeclarations namespaceDeclarations() const;
|
||||
void addExtraNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &extraNamespaceDeclaraction);
|
||||
void addExtraNamespaceDeclarations(const QXmlStreamNamespaceDeclarations &extraNamespaceDeclaractions);
|
||||
QXmlStreamNotationDeclarations notationDeclarations() const;
|
||||
QXmlStreamEntityDeclarations entityDeclarations() const;
|
||||
XmlStreamNamespaceDeclarations namespaceDeclarations() const;
|
||||
void addExtraNamespaceDeclaration(const XmlStreamNamespaceDeclaration &extraNamespaceDeclaraction);
|
||||
void addExtraNamespaceDeclarations(const XmlStreamNamespaceDeclarations &extraNamespaceDeclaractions);
|
||||
XmlStreamNotationDeclarations notationDeclarations() const;
|
||||
XmlStreamEntityDeclarations entityDeclarations() const;
|
||||
QStringRef dtdName() const;
|
||||
QStringRef dtdPublicId() const;
|
||||
QStringRef dtdSystemId() const;
|
||||
|
|
@ -337,31 +332,30 @@ public:
|
|||
return error() != NoError;
|
||||
}
|
||||
|
||||
void setEntityResolver(QXmlStreamEntityResolver *resolver);
|
||||
QXmlStreamEntityResolver *entityResolver() const;
|
||||
void setEntityResolver(XmlStreamEntityResolver *resolver);
|
||||
XmlStreamEntityResolver *entityResolver() const;
|
||||
|
||||
private:
|
||||
Q_DISABLE_COPY(QXmlStreamReader)
|
||||
Q_DECLARE_PRIVATE(QXmlStreamReader)
|
||||
QScopedPointer<QXmlStreamReaderPrivate> d_ptr;
|
||||
Q_DISABLE_COPY(XmlStreamReader)
|
||||
Q_DECLARE_PRIVATE(XmlStreamReader)
|
||||
QScopedPointer<XmlStreamReaderPrivate> d_ptr;
|
||||
|
||||
};
|
||||
#endif // QT_NO_XMLSTREAMREADER
|
||||
|
||||
#ifndef QT_NO_XMLSTREAMWRITER
|
||||
|
||||
class QXmlStreamWriterPrivate;
|
||||
class XmlStreamWriterPrivate;
|
||||
|
||||
class Q_CORE_EXPORT QXmlStreamWriter
|
||||
class Q_CORE_EXPORT XmlStreamWriter
|
||||
{
|
||||
QDOC_PROPERTY(bool autoFormatting READ autoFormatting WRITE setAutoFormatting)
|
||||
QDOC_PROPERTY(int autoFormattingIndent READ autoFormattingIndent WRITE setAutoFormattingIndent)
|
||||
public:
|
||||
QXmlStreamWriter();
|
||||
explicit QXmlStreamWriter(QIODevice *device);
|
||||
explicit QXmlStreamWriter(QByteArray *array);
|
||||
explicit QXmlStreamWriter(QString *string);
|
||||
~QXmlStreamWriter();
|
||||
XmlStreamWriter();
|
||||
explicit XmlStreamWriter(QIODevice *device);
|
||||
explicit XmlStreamWriter(QByteArray *array);
|
||||
explicit XmlStreamWriter(QString *string);
|
||||
~XmlStreamWriter();
|
||||
|
||||
void setDevice(QIODevice *device);
|
||||
QIODevice *device() const;
|
||||
|
|
@ -380,8 +374,8 @@ public:
|
|||
|
||||
void writeAttribute(const QString &qualifiedName, const QString &value);
|
||||
void writeAttribute(const QString &namespaceUri, const QString &name, const QString &value);
|
||||
void writeAttribute(const QXmlStreamAttribute& attribute);
|
||||
void writeAttributes(const QXmlStreamAttributes& attributes);
|
||||
void writeAttribute(const XmlStreamAttribute& attribute);
|
||||
void writeAttributes(const XmlStreamAttributes& attributes);
|
||||
|
||||
void writeCDATA(const QString &text);
|
||||
void writeCharacters(const QString &text);
|
||||
|
|
@ -410,19 +404,17 @@ public:
|
|||
void writeStartElement(const QString &namespaceUri, const QString &name);
|
||||
|
||||
#ifndef QT_NO_XMLSTREAMREADER
|
||||
void writeCurrentToken(const QXmlStreamReader &reader);
|
||||
void writeCurrentToken(const XmlStreamReader &reader);
|
||||
#endif
|
||||
|
||||
bool hasError() const;
|
||||
|
||||
private:
|
||||
Q_DISABLE_COPY(QXmlStreamWriter)
|
||||
Q_DECLARE_PRIVATE(QXmlStreamWriter)
|
||||
QScopedPointer<QXmlStreamWriterPrivate> d_ptr;
|
||||
Q_DISABLE_COPY(XmlStreamWriter)
|
||||
Q_DECLARE_PRIVATE(XmlStreamWriter)
|
||||
QScopedPointer<XmlStreamWriterPrivate> d_ptr;
|
||||
};
|
||||
#endif // QT_NO_XMLSTREAMWRITER
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
#endif // QT_NO_XMLSTREAM
|
||||
#endif // QXMLSTREAM_H
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -39,8 +39,8 @@
|
|||
**
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef QXMLUTILS_P_H
|
||||
#define QXMLUTILS_P_H
|
||||
#ifndef __XMLUTILS_P_H__
|
||||
#define __XMLUTILS_P_H__
|
||||
|
||||
//
|
||||
// W A R N I N G
|
||||
|
|
@ -17,8 +17,8 @@
|
|||
#include <QStringList>
|
||||
|
||||
#include "libmscore/xml.h"
|
||||
#include "libmscore/qzipreader_p.h"
|
||||
#include "audiofile/audiofile.h"
|
||||
#include "thirdparty/qzip/qzipreader_p.h"
|
||||
|
||||
#include "instrument.h"
|
||||
#include "zone.h"
|
||||
|
|
|
|||
Loading…
Reference in a new issue