Restructure how we initialize hash nodes a little

This should help to silence coverity which was complaining
hundreds of times about Qt not initializing h and next in
QHashNode.

Change-Id: Ib7977693e9786d4b310799e4f428115c65bb3fee
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

diff --git a/src/corelib/tools/qhash.cpp b/src/corelib/tools/qhash.cpp
index a2851d1..10dcff9 100644 (file)
--- a/src/corelib/tools/qhash.cpp
+++ b/src/corelib/tools/qhash.cpp
@@ -369,7 +369,6 @@ QHashData *QHashData::detach_helper(void (*node_duplicate)(Node *, void *),
                         QT_RETHROW;
                     }
 
-                    dup->h = oldNode->h;
                     *nextNode = dup;
                     nextNode = &dup->next;
                     oldNode = oldNode->next;

diff --git a/src/corelib/tools/qhash.h b/src/corelib/tools/qhash.h
index fe6a8df..d196e6e 100644 (file)
--- a/src/corelib/tools/qhash.h
+++ b/src/corelib/tools/qhash.h
@@ -197,27 +197,29 @@ inline bool operator==(const QHashDummyValue & /* v1 */, const QHashDummyValue &
 Q_DECLARE_TYPEINFO(QHashDummyValue, Q_MOVABLE_TYPE | Q_DUMMY_TYPE);
 
 template <class Key, class T>
-struct QHashDummyNode
+struct QHashNode
 {
-    QHashDummyNode *next;
+    QHashNode *next;
     uint h;
     Key key;
+    T value;
 
-    inline QHashDummyNode(const Key &key0) : key(key0) {}
+    inline QHashNode(const Key &key0, const T &value0, uint hash, QHashNode *n)
+        : next(n), h(hash), key(key0), value(value0) {}
+    inline bool same_key(uint h0, const Key &key0) { return h0 == h && key0 == key; }
 };
 
 template <class Key, class T>
-struct QHashNode
+struct QHashDummyNode
 {
-    QHashNode *next;
+    QHashNode<Key, T> *next;
     uint h;
     Key key;
-    T value;
 
-    inline QHashNode(const Key &key0, const T &value0) : key(key0), value(value0) {}
-    inline bool same_key(uint h0, const Key &key0) { return h0 == h && key0 == key; }
+    inline QHashDummyNode(const Key &key0, uint hash, QHashNode<Key, T> *n) : next(n), h(hash), key(key0) {}
 };
 
+
 #if 0
 // ###
 // The introduction of the QHash random seed breaks this optimization, as it
@@ -519,9 +521,9 @@ Q_INLINE_TEMPLATE void QHash<Key, T>::duplicateNode(QHashData::Node *node, void
 {
     Node *concreteNode = concrete(node);
     if (QTypeInfo<T>::isDummy) {
-        (void) new (newNode) DummyNode(concreteNode->key);
+        (void) new (newNode) DummyNode(concreteNode->key, concreteNode->h, 0);
     } else {
-        (void) new (newNode) Node(concreteNode->key, concreteNode->value);
+        (void) new (newNode) Node(concreteNode->key, concreteNode->value, concreteNode->h, 0);
     }
 }
 
@@ -532,13 +534,11 @@ QHash<Key, T>::createNode(uint ah, const Key &akey, const T &avalue, Node **anex
     Node *node;
 
     if (QTypeInfo<T>::isDummy) {
-        node = reinterpret_cast<Node *>(new (d->allocateNode(alignOfDummyNode())) DummyNode(akey));
+        node = reinterpret_cast<Node *>(new (d->allocateNode(alignOfDummyNode())) DummyNode(akey, ah, *anextNode));
     } else {
-        node = new (d->allocateNode(alignOfNode())) Node(akey, avalue);
+        node = new (d->allocateNode(alignOfNode())) Node(akey, avalue, ah, *anextNode);
     }
 
-    node->h = ah;
-    node->next = *anextNode;
     *anextNode = node;
     ++d->size;
     return node;