1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtXml module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <qplatformdefs.h>

    43 #include <qdom.h>

    44 #include "private/qxmlutils_p.h"

    45 

    46 #ifndef QT_NO_DOM

    47 

    48 #include <qatomic.h>

    49 #include <qbuffer.h>

    50 #include <qhash.h>

    51 #include <qiodevice.h>

    52 #include <qlist.h>

    53 #include <qregexp.h>

    54 #include <qtextcodec.h>

    55 #include <qtextstream.h>

    56 #include <qxml.h>

    57 #include <qvariant.h>

    58 #include <qmap.h>

    59 #include <qshareddata.h>

    60 #include <qdebug.h>

    61 #include <stdio.h>

    62 

    63 QT_BEGIN_NAMESPACE

    64 

    65 /*

    66   ### old todo comments -- I don't know if they still apply...

    67 

    68   If the document dies, remove all pointers to it from children

    69   which can not be deleted at this time.

    70 

    71   If a node dies and has direct children which can not be deleted,

    72   then remove the pointer to the parent.

    73 

    74   createElement and friends create double reference counts.

    75 */

    76 

    77 /* ##### new TODOs:

    78 

    79   Remove emtpy emthods in the *Private classes

    80 

    81   Make a lot of the (mostly empty) methods in the public classes inline.

    82   Specially constructors assignment operators and comparison operators are candidates.

    83 

    84   The virtual isXxx functions in *Private can probably be replaced by inline methods checking the nodeType().

    85 */

    86 

    87 /*

    88   Reference counting:

    89 

    90   Some simple rules:

    91   1) If an intern object returns a pointer to another intern object

    92      then the reference count of the returned object is not increased.

    93   2) If an extern object is created and gets a pointer to some intern

    94      object, then the extern object increases the intern objects reference count.

    95   3) If an extern object is deleted, then it decreases the reference count

    96      on its associated intern object and deletes it if nobody else hold references

    97      on the intern object.

    98 */

    99 

   100 

   101 /*

   102   Helper to split a qualified name in the prefix and local name.

   103 */

   104 static void qt_split_namespace(QString& prefix, QString& name, const QString& qName, bool hasURI)

   105 {

   106     int i = qName.indexOf(QLatin1Char(':'));

   107     if (i == -1) {

   108         if (hasURI)

   109             prefix = QLatin1String("");

   110         else

   111             prefix.clear();

   112         name = qName;

   113     } else {

   114         prefix = qName.left(i);

   115         name = qName.mid(i + 1);

   116     }

   117 }

   118 

   119 /**************************************************************

   120  *

   121  * Private class declerations

   122  *

   123  **************************************************************/

   124 

   125 class QDomImplementationPrivate

   126 {

   127 public:

   128     inline QDomImplementationPrivate() {}

   129 

   130     QDomImplementationPrivate* clone();

   131     QAtomicInt ref;

   132     static QDomImplementation::InvalidDataPolicy invalidDataPolicy;

   133 };

   134 

   135 class QDomNodePrivate

   136 {

   137 public:

   138     QDomNodePrivate(QDomDocumentPrivate*, QDomNodePrivate* parent = 0);

   139     QDomNodePrivate(QDomNodePrivate* n, bool deep);

   140     virtual ~QDomNodePrivate();

   141 

   142     QString nodeName() const { return name; }

   143     QString nodeValue() const { return value; }

   144     virtual void setNodeValue(const QString& v) { value = v; }

   145 

   146     QDomDocumentPrivate* ownerDocument();

   147     void setOwnerDocument(QDomDocumentPrivate* doc);

   148 

   149     virtual QDomNodePrivate* insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild);

   150     virtual QDomNodePrivate* insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild);

   151     virtual QDomNodePrivate* replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild);

   152     virtual QDomNodePrivate* removeChild(QDomNodePrivate* oldChild);

   153     virtual QDomNodePrivate* appendChild(QDomNodePrivate* newChild);

   154 

   155     QDomNodePrivate* namedItem(const QString& name);

   156 

   157     virtual QDomNodePrivate* cloneNode(bool deep = true);

   158     virtual void normalize();

   159     virtual void clear();

   160 

   161     inline QDomNodePrivate* parent() const { return hasParent ? ownerNode : 0; }

   162     inline void setParent(QDomNodePrivate *p) { ownerNode = p; hasParent = true; }

   163 

   164     void setNoParent() {

   165         ownerNode = hasParent ? (QDomNodePrivate*)ownerDocument() : 0;

   166         hasParent = false;

   167     }

   168 

   169     // Dynamic cast

   170     virtual bool isAttr() const                     { return false; }

   171     virtual bool isCDATASection() const             { return false; }

   172     virtual bool isDocumentFragment() const         { return false; }

   173     virtual bool isDocument() const                 { return false; }

   174     virtual bool isDocumentType() const             { return false; }

   175     virtual bool isElement() const                  { return false; }

   176     virtual bool isEntityReference() const          { return false; }

   177     virtual bool isText() const                     { return false; }

   178     virtual bool isEntity() const                   { return false; }

   179     virtual bool isNotation() const                 { return false; }

   180     virtual bool isProcessingInstruction() const    { return false; }

   181     virtual bool isCharacterData() const            { return false; }

   182     virtual bool isComment() const                  { return false; }

   183 

   184     virtual QDomNode::NodeType nodeType() const { return QDomNode::BaseNode; }

   185 

   186     virtual void save(QTextStream&, int, int) const;

   187 

   188     void setLocation(int lineNumber, int columnNumber);

   189 

   190     // Variables

   191     QAtomicInt ref;

   192     QDomNodePrivate* prev;

   193     QDomNodePrivate* next;

   194     QDomNodePrivate* ownerNode; // either the node's parent or the node's owner document

   195     QDomNodePrivate* first;

   196     QDomNodePrivate* last;

   197 

   198     QString name; // this is the local name if prefix != null

   199     QString value;

   200     QString prefix; // set this only for ElementNode and AttributeNode

   201     QString namespaceURI; // set this only for ElementNode and AttributeNode

   202     bool createdWithDom1Interface : 1;

   203     bool hasParent                : 1;

   204 

   205     int lineNumber;

   206     int columnNumber;

   207 };

   208 

   209 class QDomNodeListPrivate

   210 {

   211 public:

   212     QDomNodeListPrivate(QDomNodePrivate*);

   213     QDomNodeListPrivate(QDomNodePrivate*, const QString& );

   214     QDomNodeListPrivate(QDomNodePrivate*, const QString&, const QString& );

   215     ~QDomNodeListPrivate();

   216 

   217     bool operator== (const QDomNodeListPrivate&) const;

   218     bool operator!= (const QDomNodeListPrivate&) const;

   219 

   220     void createList();

   221     QDomNodePrivate* item(int index);

   222     uint length() const;

   223 

   224     QAtomicInt ref;

   225     /*

   226       This list contains the children of this node.

   227      */

   228     QDomNodePrivate* node_impl;

   229     QString tagname;

   230     QString nsURI;

   231     QList<QDomNodePrivate*> list;

   232     long timestamp;

   233 };

   234 

   235 class QDomNamedNodeMapPrivate

   236 {

   237 public:

   238     QDomNamedNodeMapPrivate(QDomNodePrivate*);

   239     ~QDomNamedNodeMapPrivate();

   240 

   241     QDomNodePrivate* namedItem(const QString& name) const;

   242     QDomNodePrivate* namedItemNS(const QString& nsURI, const QString& localName) const;

   243     QDomNodePrivate* setNamedItem(QDomNodePrivate* arg);

   244     QDomNodePrivate* setNamedItemNS(QDomNodePrivate* arg);

   245     QDomNodePrivate* removeNamedItem(const QString& name);

   246     QDomNodePrivate* item(int index) const;

   247     uint length() const;

   248     bool contains(const QString& name) const;

   249     bool containsNS(const QString& nsURI, const QString & localName) const;

   250 

   251     /**

   252      * Remove all children from the map.

   253      */

   254     void clearMap();

   255     bool isReadOnly() { return readonly; }

   256     void setReadOnly(bool r) { readonly = r; }

   257     bool isAppendToParent() { return appendToParent; }

   258     /**

   259      * If true, then the node will redirect insert/remove calls

   260      * to its parent by calling QDomNodePrivate::appendChild or removeChild.

   261      * In addition the map wont increase or decrease the reference count

   262      * of the nodes it contains.

   263      *

   264      * By default this value is false and the map will handle reference counting

   265      * by itself.

   266      */

   267     void setAppendToParent(bool b) { appendToParent = b; }

   268 

   269     /**

   270      * Creates a copy of the map. It is a deep copy

   271      * that means that all children are cloned.

   272      */

   273     QDomNamedNodeMapPrivate* clone(QDomNodePrivate* parent);

   274 

   275     // Variables

   276     QAtomicInt ref;

   277     QHash<QString, QDomNodePrivate *> map;

   278     QDomNodePrivate* parent;

   279     bool readonly;

   280     bool appendToParent;

   281 };

   282 

   283 class QDomDocumentTypePrivate : public QDomNodePrivate

   284 {

   285 public:

   286     QDomDocumentTypePrivate(QDomDocumentPrivate*, QDomNodePrivate* parent = 0);

   287     QDomDocumentTypePrivate(QDomDocumentTypePrivate* n, bool deep);

   288     ~QDomDocumentTypePrivate();

   289     void init();

   290 

   291     // Reimplemented from QDomNodePrivate

   292     QDomNodePrivate* cloneNode(bool deep = true);

   293     QDomNodePrivate* insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild);

   294     QDomNodePrivate* insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild);

   295     QDomNodePrivate* replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild);

   296     QDomNodePrivate* removeChild(QDomNodePrivate* oldChild);

   297     QDomNodePrivate* appendChild(QDomNodePrivate* newChild);

   298 

   299     virtual bool isDocumentType() const { return true; }

   300     QDomNode::NodeType nodeType() const { return QDomNode::DocumentTypeNode; }

   301 

   302     void save(QTextStream& s, int, int) const;

   303 

   304     // Variables

   305     QDomNamedNodeMapPrivate* entities;

   306     QDomNamedNodeMapPrivate* notations;

   307     QString publicId;

   308     QString systemId;

   309     QString internalSubset;

   310 };

   311 

   312 class QDomDocumentFragmentPrivate : public QDomNodePrivate

   313 {

   314 public:

   315     QDomDocumentFragmentPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent = 0);

   316     QDomDocumentFragmentPrivate(QDomNodePrivate* n, bool deep);

   317 

   318     // Reimplemented from QDomNodePrivate

   319     virtual QDomNodePrivate* cloneNode(bool deep = true);

   320     virtual bool isDocumentFragment() const { return true; }

   321     QDomNode::NodeType nodeType() const { return QDomNode::DocumentFragmentNode; }

   322 };

   323 

   324 class QDomCharacterDataPrivate : public QDomNodePrivate

   325 {

   326 public:

   327     QDomCharacterDataPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& data);

   328     QDomCharacterDataPrivate(QDomCharacterDataPrivate* n, bool deep);

   329 

   330     uint dataLength() const;

   331     QString substringData(unsigned long offset, unsigned long count) const;

   332     void appendData(const QString& arg);

   333     void insertData(unsigned long offset, const QString& arg);

   334     void deleteData(unsigned long offset, unsigned long count);

   335     void replaceData(unsigned long offset, unsigned long count, const QString& arg);

   336 

   337     // Reimplemented from QDomNodePrivate

   338     virtual bool isCharacterData() const { return true; }

   339     QDomNode::NodeType nodeType() const { return QDomNode::CharacterDataNode; }

   340     QDomNodePrivate* cloneNode(bool deep = true);

   341 };

   342 

   343 class QDomTextPrivate : public QDomCharacterDataPrivate

   344 {

   345 public:

   346     QDomTextPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& val);

   347     QDomTextPrivate(QDomTextPrivate* n, bool deep);

   348 

   349     QDomTextPrivate* splitText(int offset);

   350 

   351     // Reimplemented from QDomNodePrivate

   352     QDomNodePrivate* cloneNode(bool deep = true);

   353     virtual bool isText() const { return true; }

   354     QDomNode::NodeType nodeType() const { return QDomNode::TextNode; }

   355     virtual void save(QTextStream& s, int, int) const;

   356 };

   357 

   358 class QDomAttrPrivate : public QDomNodePrivate

   359 {

   360 public:

   361     QDomAttrPrivate(QDomDocumentPrivate*, QDomNodePrivate*, const QString& name);

   362     QDomAttrPrivate(QDomDocumentPrivate*, QDomNodePrivate*, const QString& nsURI, const QString& qName);

   363     QDomAttrPrivate(QDomAttrPrivate* n, bool deep);

   364 

   365     bool specified() const;

   366 

   367     // Reimplemented from QDomNodePrivate

   368     void setNodeValue(const QString& v);

   369     QDomNodePrivate* cloneNode(bool deep = true);

   370     virtual bool isAttr() const { return true; }

   371     QDomNode::NodeType nodeType() const { return QDomNode::AttributeNode; }

   372     virtual void save(QTextStream& s, int, int) const;

   373 

   374     // Variables

   375     bool m_specified;

   376 };

   377 

   378 class QDomElementPrivate : public QDomNodePrivate

   379 {

   380 public:

   381     QDomElementPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& name);

   382     QDomElementPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& nsURI, const QString& qName);

   383     QDomElementPrivate(QDomElementPrivate* n, bool deep);

   384     ~QDomElementPrivate();

   385 

   386     QString attribute(const QString& name, const QString& defValue) const;

   387     QString attributeNS(const QString& nsURI, const QString& localName, const QString& defValue) const;

   388     void setAttribute(const QString& name, const QString& value);

   389     void setAttributeNS(const QString& nsURI, const QString& qName, const QString& newValue);

   390     void removeAttribute(const QString& name);

   391     QDomAttrPrivate* attributeNode(const QString& name);

   392     QDomAttrPrivate* attributeNodeNS(const QString& nsURI, const QString& localName);

   393     QDomAttrPrivate* setAttributeNode(QDomAttrPrivate* newAttr);

   394     QDomAttrPrivate* setAttributeNodeNS(QDomAttrPrivate* newAttr);

   395     QDomAttrPrivate* removeAttributeNode(QDomAttrPrivate* oldAttr);

   396     bool hasAttribute(const QString& name);

   397     bool hasAttributeNS(const QString& nsURI, const QString& localName);

   398 

   399     QString text();

   400 

   401     // Reimplemented from QDomNodePrivate

   402     QDomNamedNodeMapPrivate* attributes() { return m_attr; }

   403     bool hasAttributes() { return (m_attr->length() > 0); }

   404     virtual bool isElement() const { return true; }

   405     QDomNode::NodeType nodeType() const { return QDomNode::ElementNode; }

   406     QDomNodePrivate* cloneNode(bool deep = true);

   407     virtual void save(QTextStream& s, int, int) const;

   408 

   409     // Variables

   410     QDomNamedNodeMapPrivate* m_attr;

   411 };

   412 

   413 

   414 class QDomCommentPrivate : public QDomCharacterDataPrivate

   415 {

   416 public:

   417     QDomCommentPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& val);

   418     QDomCommentPrivate(QDomCommentPrivate* n, bool deep);

   419 

   420     // Reimplemented from QDomNodePrivate

   421     QDomNodePrivate* cloneNode(bool deep = true);

   422     virtual bool isComment() const { return true; }

   423     QDomNode::NodeType nodeType() const { return QDomNode::CommentNode; }

   424     virtual void save(QTextStream& s, int, int) const;

   425 };

   426 

   427 class QDomCDATASectionPrivate : public QDomTextPrivate

   428 {

   429 public:

   430     QDomCDATASectionPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& val);

   431     QDomCDATASectionPrivate(QDomCDATASectionPrivate* n, bool deep);

   432 

   433     // Reimplemented from QDomNodePrivate

   434     QDomNodePrivate* cloneNode(bool deep = true);

   435     virtual bool isCDATASection() const { return true; }

   436     QDomNode::NodeType nodeType() const { return QDomNode::CDATASectionNode; }

   437     virtual void save(QTextStream& s, int, int) const;

   438 };

   439 

   440 class QDomNotationPrivate : public QDomNodePrivate

   441 {

   442 public:

   443     QDomNotationPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& name,

   444                           const QString& pub, const QString& sys);

   445     QDomNotationPrivate(QDomNotationPrivate* n, bool deep);

   446 

   447     // Reimplemented from QDomNodePrivate

   448     QDomNodePrivate* cloneNode(bool deep = true);

   449     virtual bool isNotation() const { return true; }

   450     QDomNode::NodeType nodeType() const { return QDomNode::NotationNode; }

   451     virtual void save(QTextStream& s, int, int) const;

   452 

   453     // Variables

   454     QString m_sys;

   455     QString m_pub;

   456 };

   457 

   458 class QDomEntityPrivate : public QDomNodePrivate

   459 {

   460 public:

   461     QDomEntityPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& name,

   462                         const QString& pub, const QString& sys, const QString& notation);

   463     QDomEntityPrivate(QDomEntityPrivate* n, bool deep);

   464 

   465     // Reimplemented from QDomNodePrivate

   466     QDomNodePrivate* cloneNode(bool deep = true);

   467     virtual bool isEntity() const { return true; }

   468     QDomNode::NodeType nodeType() const { return QDomNode::EntityNode; }

   469     virtual void save(QTextStream& s, int, int) const;

   470 

   471     // Variables

   472     QString m_sys;

   473     QString m_pub;

   474     QString m_notationName;

   475 };

   476 

   477 class QDomEntityReferencePrivate : public QDomNodePrivate

   478 {

   479 public:

   480     QDomEntityReferencePrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& name);

   481     QDomEntityReferencePrivate(QDomNodePrivate* n, bool deep);

   482 

   483     // Reimplemented from QDomNodePrivate

   484     QDomNodePrivate* cloneNode(bool deep = true);

   485     bool isEntityReference() const { return true; }

   486     QDomNode::NodeType nodeType() const { return QDomNode::EntityReferenceNode; }

   487     virtual void save(QTextStream& s, int, int) const;

   488 };

   489 

   490 class QDomProcessingInstructionPrivate : public QDomNodePrivate

   491 {

   492 public:

   493     QDomProcessingInstructionPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& target,

   494                                        const QString& data);

   495     QDomProcessingInstructionPrivate(QDomProcessingInstructionPrivate* n, bool deep);

   496 

   497     // Reimplemented from QDomNodePrivate

   498     QDomNodePrivate* cloneNode(bool deep = true);

   499     virtual bool isProcessingInstruction() const { return true; }

   500     QDomNode::NodeType nodeType() const { return QDomNode::ProcessingInstructionNode; }

   501     virtual void save(QTextStream& s, int, int) const;

   502 };

   503 

   504 class QDomDocumentPrivate : public QDomNodePrivate

   505 {

   506 public:

   507     QDomDocumentPrivate();

   508     QDomDocumentPrivate(const QString& name);

   509     QDomDocumentPrivate(QDomDocumentTypePrivate* dt);

   510     QDomDocumentPrivate(QDomDocumentPrivate* n, bool deep);

   511     ~QDomDocumentPrivate();

   512 

   513     bool setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn);

   514     bool setContent(QXmlInputSource *source, QXmlReader *reader, QString *errorMsg, int *errorLine, int *errorColumn);

   515 

   516     // Attributes

   517     QDomDocumentTypePrivate* doctype() { return type.data(); }

   518     QDomImplementationPrivate* implementation() { return impl.data(); }

   519     QDomElementPrivate* documentElement();

   520 

   521     // Factories

   522     QDomElementPrivate* createElement(const QString& tagName);

   523     QDomElementPrivate*        createElementNS(const QString& nsURI, const QString& qName);

   524     QDomDocumentFragmentPrivate* createDocumentFragment();

   525     QDomTextPrivate* createTextNode(const QString& data);

   526     QDomCommentPrivate* createComment(const QString& data);

   527     QDomCDATASectionPrivate* createCDATASection(const QString& data);

   528     QDomProcessingInstructionPrivate* createProcessingInstruction(const QString& target, const QString& data);

   529     QDomAttrPrivate* createAttribute(const QString& name);

   530     QDomAttrPrivate* createAttributeNS(const QString& nsURI, const QString& qName);

   531     QDomEntityReferencePrivate* createEntityReference(const QString& name);

   532 

   533     QDomNodePrivate* importNode(const QDomNodePrivate* importedNode, bool deep);

   534 

   535     // Reimplemented from QDomNodePrivate

   536     QDomNodePrivate* cloneNode(bool deep = true);

   537     bool isDocument() const { return true; }

   538     QDomNode::NodeType nodeType() const { return QDomNode::DocumentNode; }

   539     void clear();

   540 

   541     // Variables

   542     QExplicitlySharedDataPointer<QDomImplementationPrivate> impl;

   543     QExplicitlySharedDataPointer<QDomDocumentTypePrivate> type;

   544 

   545     void saveDocument(QTextStream& stream, const int indent, QDomNode::EncodingPolicy encUsed) const;

   546 

   547     /* \internal

   548        Counter for the QDomNodeListPrivate timestamps.

   549 

   550        This is a cache optimization, that might in some cases be effective. The

   551        dilemma is that QDomNode::childNodes() returns a list, but the

   552        implementation stores the children in a linked list. Hence, in order to

   553        get the children out through childNodes(), a list must be populated each

   554        time, which is O(N).

   555 

   556        DOM has the requirement of node references being live, see DOM Core

   557        Level 3, 1.1.1 The DOM Structure Model, which means that changes to the

   558        underlying documents must be reflected in node lists.

   559 

   560        This mechanism, nodeListTime, is a caching optimization that reduces the

   561        amount of times the node list is rebuilt, by only doing so when the

   562        document actually changes. However, a change to anywhere in any document

   563        invalidate all lists, since no dependency tracking is done.

   564 

   565        It functions by that all modifying functions(insertBefore() and so on)

   566        increment the count; each QDomNodeListPrivate copies nodeListTime on

   567        construction, and compares its own value to nodeListTime in order to

   568        determine whether it needs to rebuild.

   569 

   570        This is reentrant. The nodeListTime may overflow, but that's ok since we

   571        check for equalness, not whether nodeListTime is smaller than the list's

   572        stored timestamp.

   573     */

   574     long nodeListTime;

   575 };

   576 

   577 /**************************************************************

   578  *

   579  * QDomHandler

   580  *

   581  **************************************************************/

   582 

   583 class QDomHandler : public QXmlDefaultHandler

   584 {

   585 public:

   586     QDomHandler(QDomDocumentPrivate* d, bool namespaceProcessing);

   587     ~QDomHandler();

   588 

   589     // content handler

   590     bool endDocument();

   591     bool startElement(const QString& nsURI, const QString& localName, const QString& qName, const QXmlAttributes& atts);

   592     bool endElement(const QString& nsURI, const QString& localName, const QString& qName);

   593     bool characters(const QString& ch);

   594     bool processingInstruction(const QString& target, const QString& data);

   595     bool skippedEntity(const QString& name);

   596 

   597     // error handler

   598     bool fatalError(const QXmlParseException& exception);

   599 

   600     // lexical handler

   601     bool startCDATA();

   602     bool endCDATA();

   603     bool startEntity(const QString &);

   604     bool endEntity(const QString &);

   605     bool startDTD(const QString& name, const QString& publicId, const QString& systemId);

   606     bool comment(const QString& ch);

   607 

   608     // decl handler

   609     bool externalEntityDecl(const QString &name, const QString &publicId, const QString &systemId) ;

   610 

   611     // DTD handler

   612     bool notationDecl(const QString & name, const QString & publicId, const QString & systemId);

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

   614 

   615     void setDocumentLocator(QXmlLocator *locator);

   616 

   617     QString errorMsg;

   618     int errorLine;

   619     int errorColumn;

   620 

   621 private:

   622     QDomDocumentPrivate *doc;

   623     QDomNodePrivate *node;

   624     QString entityName;

   625     bool cdata;

   626     bool nsProcessing;

   627     QXmlLocator *locator;

   628 };

   629 

   630 /**************************************************************

   631  *

   632  * Functions for verifying legal data

   633  *

   634  **************************************************************/

   635 QDomImplementation::InvalidDataPolicy QDomImplementationPrivate::invalidDataPolicy

   636     = QDomImplementation::AcceptInvalidChars;

   637 

   638 // [5] Name ::= (Letter | '_' | ':') (NameChar)*

   639 

   640 static QString fixedXmlName(const QString &_name, bool *ok, bool namespaces = false)

   641 {

   642     QString name, prefix;

   643     if (namespaces)

   644         qt_split_namespace(prefix, name, _name, true);

   645     else

   646         name = _name;

   647 

   648     if (name.isEmpty()) {

   649         *ok = false;

   650         return QString();

   651     }

   652 

   653     if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {

   654         *ok = true;

   655         return _name;

   656     }

   657 

   658     QString result;

   659     bool firstChar = true;

   660     for (int i = 0; i < name.size(); ++i) {

   661         QChar c = name.at(i);

   662         if (firstChar) {

   663             if (QXmlUtils::isLetter(c) || c.unicode() == '_' || c.unicode() == ':') {

   664                 result.append(c);

   665                 firstChar = false;

   666             } else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {

   667                 *ok = false;

   668                 return QString();

   669             }

   670         } else {

   671             if (QXmlUtils::isNameChar(c))

   672                 result.append(c);

   673             else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {

   674                 *ok = false;

   675                 return QString();

   676             }

   677         }

   678     }

   679 

   680     if (result.isEmpty()) {

   681         *ok = false;

   682         return QString();

   683     }

   684 

   685     *ok = true;

   686     if (namespaces && !prefix.isEmpty())

   687         return prefix + QLatin1Char(':') + result;

   688     return result;

   689 }

   690 

   691 // [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)

   692 // '<', '&' and "]]>" will be escaped when writing

   693 

   694 static QString fixedCharData(const QString &data, bool *ok)

   695 {

   696     if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {

   697         *ok = true;

   698         return data;

   699     }

   700 

   701     QString result;

   702     for (int i = 0; i < data.size(); ++i) {

   703         QChar c = data.at(i);

   704         if (QXmlUtils::isChar(c)) {

   705             result.append(c);

   706         } else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {

   707             *ok = false;

   708             return QString();

   709         }

   710     }

   711 

   712     *ok = true;

   713     return result;

   714 }

   715 

   716 // [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'

   717 // can't escape "--", since entities are not recognised within comments

   718 

   719 static QString fixedComment(const QString &data, bool *ok)

   720 {

   721     if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {

   722         *ok = true;

   723         return data;

   724     }

   725 

   726     QString fixedData = fixedCharData(data, ok);

   727     if (!*ok)

   728         return QString();

   729 

   730     for (;;) {

   731         int idx = fixedData.indexOf(QLatin1String("--"));

   732         if (idx == -1)

   733             break;

   734         if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {

   735             *ok = false;

   736             return QString();

   737         }

   738         fixedData.remove(idx, 2);

   739     }

   740 

   741     *ok = true;

   742     return fixedData;

   743 }

   744 

   745 // [20] CData ::= (Char* - (Char* ']]>' Char*))

   746 // can't escape "]]>", since entities are not recognised within comments

   747 

   748 static QString fixedCDataSection(const QString &data, bool *ok)

   749 {

   750     if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {

   751         *ok = true;

   752         return data;

   753     }

   754 

   755     QString fixedData = fixedCharData(data, ok);

   756     if (!*ok)

   757         return QString();

   758 

   759     for (;;) {

   760         int idx = fixedData.indexOf(QLatin1String("]]>"));

   761         if (idx == -1)

   762             break;

   763         if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {

   764             *ok = false;

   765             return QString();

   766         }

   767         fixedData.remove(idx, 3);

   768     }

   769 

   770     *ok = true;

   771     return fixedData;

   772 }

   773 

   774 // [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'

   775 

   776 static QString fixedPIData(const QString &data, bool *ok)

   777 {

   778     if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {

   779         *ok = true;

   780         return data;

   781     }

   782 

   783     QString fixedData = fixedCharData(data, ok);

   784     if (!*ok)

   785         return QString();

   786 

   787     for (;;) {

   788         int idx = fixedData.indexOf(QLatin1String("?>"));

   789         if (idx == -1)

   790             break;

   791         if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {

   792             *ok = false;

   793             return QString();

   794         }

   795         fixedData.remove(idx, 2);

   796     }

   797 

   798     *ok = true;

   799     return fixedData;

   800 }

   801 

   802 // [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"

   803 // The correct quote will be chosen when writing

   804 

   805 static QString fixedPubidLiteral(const QString &data, bool *ok)

   806 {

   807     if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {

   808         *ok = true;

   809         return data;

   810     }

   811 

   812     QString result;

   813 

   814     if(QXmlUtils::isPublicID(data))

   815         result = data;

   816     else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {

   817         *ok = false;

   818         return QString();

   819     }

   820 

   821     if (result.indexOf(QLatin1Char('\'')) != -1

   822         && result.indexOf(QLatin1Char('"')) != -1) {

   823         if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {

   824             *ok = false;

   825             return QString();

   826         } else {

   827             result.remove(QLatin1Char('\''));

   828         }

   829     }

   830 

   831     *ok = true;

   832     return result;

   833 }

   834 

   835 // [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")

   836 // The correct quote will be chosen when writing

   837 

   838 static QString fixedSystemLiteral(const QString &data, bool *ok)

   839 {

   840     if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {

   841         *ok = true;

   842         return data;

   843     }

   844 

   845     QString result = data;

   846 

   847     if (result.indexOf(QLatin1Char('\'')) != -1

   848         && result.indexOf(QLatin1Char('"')) != -1) {

   849         if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {

   850             *ok = false;

   851             return QString();

   852         } else {

   853             result.remove(QLatin1Char('\''));

   854         }

   855     }

   856 

   857     *ok = true;

   858     return result;

   859 }

   860 

   861 /**************************************************************

   862  *

   863  * QDomImplementationPrivate

   864  *

   865  **************************************************************/

   866 

   867 QDomImplementationPrivate* QDomImplementationPrivate::clone()

   868 {

   869     return new QDomImplementationPrivate;

   870 }

   871 

   872 /**************************************************************

   873  *

   874  * QDomImplementation

   875  *

   876  **************************************************************/

   877 

   878 /*!

   879     \class QDomImplementation

   880     \reentrant

   881     \brief The QDomImplementation class provides information about the

   882     features of the DOM implementation.

   883 

   884     \inmodule QtXml

   885     \ingroup xml-tools

   886 

   887     This class describes the features that are supported by the DOM

   888     implementation. Currently the XML subset of DOM Level 1 and DOM

   889     Level 2 Core are supported.

   890 

   891     Normally you will use the function QDomDocument::implementation()

   892     to get the implementation object.

   893 

   894     You can create a new document type with createDocumentType() and a

   895     new document with createDocument().

   896 

   897     For further information about the Document Object Model see

   898     \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and

   899     \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. For a more

   900     general introduction of the DOM implementation see the QDomDocument

   901     documentation.

   902 

   903     The QDom classes have a few issues of nonconformance with the XML

   904     specifications that cannot be fixed in Qt 4 without breaking backward

   905     compatibility. The QtXmlPatterns module and the QXmlStreamReader and

   906     QXmlStreamWriter classes have a higher degree of a conformance.

   907 

   908     \sa hasFeature()

   909 */

   910 

   911 /*!

   912     Constructs a QDomImplementation object.

   913 */

   914 QDomImplementation::QDomImplementation()

   915 {

   916     impl = 0;

   917 }

   918 

   919 /*!

   920     Constructs a copy of \a x.

   921 */

   922 QDomImplementation::QDomImplementation(const QDomImplementation &x)

   923 {

   924     impl = x.impl;

   925     if (impl)

   926         impl->ref.ref();

   927 }

   928 

   929 QDomImplementation::QDomImplementation(QDomImplementationPrivate *p)

   930 {

   931     // We want to be co-owners, so increase the reference count

   932     impl = p;

   933     if (impl)

   934         impl->ref.ref();

   935 }

   936 

   937 /*!

   938     Assigns \a x to this DOM implementation.

   939 */

   940 QDomImplementation& QDomImplementation::operator=(const QDomImplementation &x)

   941 {

   942     if (x.impl)

   943         x.impl->ref.ref();

   944     if (impl && !impl->ref.deref())

   945         delete impl;

   946     impl = x.impl;

   947     return *this;

   948 }

   949 

   950 /*!

   951     Returns true if \a x and this DOM implementation object were

   952     created from the same QDomDocument; otherwise returns false.

   953 */

   954 bool QDomImplementation::operator==(const QDomImplementation &x) const

   955 {

   956     return (impl == x.impl);

   957 }

   958 

   959 /*!

   960     Returns true if \a x and this DOM implementation object were

   961     created from different QDomDocuments; otherwise returns false.

   962 */

   963 bool QDomImplementation::operator!=(const QDomImplementation &x) const

   964 {

   965     return (impl != x.impl);

   966 }

   967 

   968 /*!

   969     Destroys the object and frees its resources.

   970 */

   971 QDomImplementation::~QDomImplementation()

   972 {

   973     if (impl && !impl->ref.deref())

   974         delete impl;

   975 }

   976 

   977 /*!

   978     The function returns true if QDom implements the requested \a

   979     version of a \a feature; otherwise returns false.

   980 

   981     The currently supported features and their versions:

   982     \table

   983     \header \i Feature \i Version

   984     \row \i XML \i 1.0

   985     \endtable

   986 */

   987 bool QDomImplementation::hasFeature(const QString& feature, const QString& version) const

   988 {

   989     if (feature == QLatin1String("XML")) {

   990         if (version.isEmpty() || version == QLatin1String("1.0")) {

   991             return true;

   992         }

   993     }

   994     // ### add DOM level 2 features

   995     return false;

   996 }

   997 

   998 /*!

   999     Creates a document type node for the name \a qName.

  1000 

  1001     \a publicId specifies the public identifier of the external

  1002     subset. If you specify an empty string (QString()) as the \a

  1003     publicId, this means that the document type has no public

  1004     identifier.

  1005 

  1006     \a systemId specifies the system identifier of the external

  1007     subset. If you specify an empty string as the \a systemId, this

  1008     means that the document type has no system identifier.

  1009 

  1010     Since you cannot have a public identifier without a system

  1011     identifier, the public identifier is set to an empty string if

  1012     there is no system identifier.

  1013 

  1014     DOM level 2 does not support any other document type declaration

  1015     features.

  1016 

  1017     The only way you can use a document type that was created this

  1018     way, is in combination with the createDocument() function to

  1019     create a QDomDocument with this document type.

  1020 

  1021     In the DOM specification, this is the only way to create a non-null

  1022     document. For historical reasons, Qt also allows to create the

  1023     document using the default empty constructor. The resulting document

  1024     is null, but becomes non-null when a factory function, for example

  1025     QDomDocument::createElement(), is called. The document also becomes

  1026     non-null when setContent() is called.

  1027 

  1028     \sa createDocument()

  1029 */

  1030 QDomDocumentType QDomImplementation::createDocumentType(const QString& qName, const QString& publicId, const QString& systemId)

  1031 {

  1032     bool ok;

  1033     QString fixedName = fixedXmlName(qName, &ok, true);

  1034     if (!ok)

  1035         return QDomDocumentType();

  1036 

  1037     QString fixedPublicId = fixedPubidLiteral(publicId, &ok);

  1038     if (!ok)

  1039         return QDomDocumentType();

  1040 

  1041     QString fixedSystemId = fixedSystemLiteral(systemId, &ok);

  1042     if (!ok)

  1043         return QDomDocumentType();

  1044 

  1045     QDomDocumentTypePrivate *dt = new QDomDocumentTypePrivate(0);

  1046     dt->name = fixedName;

  1047     if (systemId.isNull()) {

  1048         dt->publicId.clear();

  1049         dt->systemId.clear();

  1050     } else {

  1051         dt->publicId = fixedPublicId;

  1052         dt->systemId = fixedSystemId;

  1053     }

  1054     dt->ref.deref();

  1055     return QDomDocumentType(dt);

  1056 }

  1057 

  1058 /*!

  1059     Creates a DOM document with the document type \a doctype. This

  1060     function also adds a root element node with the qualified name \a

  1061     qName and the namespace URI \a nsURI.

  1062 */

  1063 QDomDocument QDomImplementation::createDocument(const QString& nsURI, const QString& qName, const QDomDocumentType& doctype)

  1064 {

  1065     QDomDocument doc(doctype);

  1066     QDomElement root = doc.createElementNS(nsURI, qName);

  1067     if (root.isNull())

  1068         return QDomDocument();

  1069     doc.appendChild(root);

  1070     return doc;

  1071 }

  1072 

  1073 /*!

  1074     Returns false if the object was created by

  1075     QDomDocument::implementation(); otherwise returns true.

  1076 */

  1077 bool QDomImplementation::isNull()

  1078 {

  1079     return (impl == 0);

  1080 }

  1081 

  1082 /*!

  1083     \enum QDomImplementation::InvalidDataPolicy

  1084 

  1085     This enum specifies what should be done when a factory function

  1086     in QDomDocument is called with invalid data.

  1087     \value AcceptInvalidChars The data should be stored in the DOM object

  1088         anyway. In this case the resulting XML document might not be well-formed.

  1089         This is the default value and QDom's behavior in Qt < 4.1.

  1090     \value DropInvalidChars The invalid characters should be removed from

  1091         the data.

  1092     \value ReturnNullNode The factory function should return a null node.

  1093 

  1094     \sa setInvalidDataPolicy() invalidDataPolicy()

  1095 */

  1096 

  1097 /*!

  1098    \enum QDomNode::EncodingPolicy

  1099    \since 4.3

  1100 

  1101    This enum specifies how QDomNode::save() determines what encoding to use

  1102    when serializing.

  1103 

  1104    \value EncodingFromDocument The encoding is fetched from the document.

  1105    \value EncodingFromTextStream The encoding is fetched from the QTextStream.

  1106 

  1107    See also the overload of the save() function that takes an EncodingPolicy.

  1108 */

  1109 

  1110 /*!

  1111     \since 4.1

  1112     \nonreentrant

  1113 

  1114     Returns the invalid data policy, which specifies what should be done when

  1115     a factory function in QDomDocument is passed invalid data.

  1116 

  1117     \sa setInvalidDataPolicy() InvalidDataPolicy

  1118 */

  1119 

  1120 QDomImplementation::InvalidDataPolicy QDomImplementation::invalidDataPolicy()

  1121 {

  1122     return QDomImplementationPrivate::invalidDataPolicy;

  1123 }

  1124 

  1125 /*!

  1126     \since 4.1

  1127     \nonreentrant

  1128 

  1129     Sets the invalid data policy, which specifies what should be done when

  1130     a factory function in QDomDocument is passed invalid data.

  1131 

  1132     The \a policy is set for all instances of QDomDocument which already

  1133     exist and which will be created in the future.

  1134 

  1135     \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 0