Debugger: Fix std::{unordered_,}{map,set} dumper for libc++

Task-number: QTCREATORBUG-18536
Change-Id: I2842a525e99e4fcd9544a1f15bd42fd5c8c0c16e
Reviewed-by: hjk <hjk@qt.io>
Reviewed-by: Jeremy Barenholtz <jeremy@illiteratecoder.com>

share/qtcreator/debugger/stdtypes.py

@@ -507,23 +507,30 @@ def std1TreeNext(d, node):
     return node['__parent_']
 
 def qdump__std____1__set(d, value):
-    tree = value["__tree_"]
+    (proxy, head, size) = value.split("ppp")
-    base3 = tree["__pair3_"].address()
+
-    size = d.extractUInt(base3)
+    d.check(0 <= size and size <= 100*1000*1000)
-    d.check(size <= 100*1000*1000)
     d.putItemCount(size)
+
     if d.isExpanded():
-        # type of node is std::__1::__tree_node<Foo, void *>::value_type
         valueType = value.type[0]
-        d.putFields(tree)
+
-        node = tree["__begin_node_"]
+        def in_order_traversal(node):
-        nodeType = node.type
+            (left, right, parent, color, pad, data) = d.split("pppB@{%s}" % (valueType.name), node)
-        with Children(d, size):
+
-            for i in d.childRange():
+            if left:
-                with SubItem(d, i):
+                for res in in_order_traversal(left):
-                    d.putItem(node['__value_'])
+                    yield res
-                    d.putBetterType(valueType)
+
-                node = std1TreeNext(d, node).cast(nodeType)
+            yield data
+
+            if right:
+                for res in in_order_traversal(right):
+                    yield res
+
+        with Children(d, size, maxNumChild=1000):
+            for (i, data) in zip(d.childRange(), in_order_traversal(head)):
+                d.putSubItem(i, data)
 
 def qdump__std____1__multiset(d, value):
     qdump__std____1__set(d, value)
@@ -532,24 +539,38 @@ def qform__std____1__map():
     return mapForms()
 
 def qdump__std____1__map(d, value):
-    tree = value["__tree_"]
+    try:
-    base3 = tree["__pair3_"].address()
+        (proxy, head, size) = value.split("ppp")
-    size = d.extractUInt(base3)
+        d.check(0 <= size and size <= 100*1000*1000)
-    d.check(size <= 100*1000*1000)
+
+    # Sometimes there is extra data at the front. Don't know why at the moment.
+    except RuntimeError:
+        (junk, proxy, head, size) = value.split("pppp")
+        d.check(0 <= size and size <= 100*1000*1000)
+
     d.putItemCount(size)
+
     if d.isExpanded():
-        # type of node is std::__1::__tree_node<Foo, Bar>::value_type
+        keyType = value.type[0]
-        valueType = value.type[0]
+        valueType = value.type[1]
-        node = tree["__begin_node_"]
+        pairType = value.type[3][0]
-        nodeType = node.type
+
+        def in_order_traversal(node):
+            (left, right, parent, color, pad, pair) = d.split("pppB@{%s}" % (pairType.name), node)
+
+            if left:
+                for res in in_order_traversal(left):
+                    yield res
+
+            yield pair.split("{%s}@{%s}" % (keyType.name, valueType.name))[::2]
+
+            if right:
+                for res in in_order_traversal(right):
+                    yield res
+
         with Children(d, size, maxNumChild=1000):
-            node = tree["__begin_node_"]
+            for (i, pair) in zip(d.childRange(), in_order_traversal(head)):
-            for i in d.childRange():
+                d.putPairItem(i, pair, 'key', 'value')
-                # There's possibly also:
-                #pair = node['__value_']['__nc']
-                pair = node['__value_']['__cc']
-                d.putPairItem(i, pair)
-                node = std1TreeNext(d, node).cast(nodeType)
 
 def qform__std____1__multimap():
     return mapForms()
@@ -833,32 +854,45 @@ def qform__std____1__unordered_map():
     return mapForms()
 
 def qdump__std____1__unordered_map(d, value):
-    size = value["__table_"]["__p2_"]["__first_"].integer()
+    (size, _) = value["__table_"]["__p2_"].split("pp")
     d.putItemCount(size)
-    if d.isExpanded():
-        # There seem to be several versions of the implementation.
-        def valueCCorNot(val):
-            try:
-                return val["__cc"]
-            except:
-                return val
 
-        node = value["__table_"]["__p1_"]["__first_"]["__next_"]
+    keyType = value.type[0]
-        with Children(d, size):
+    valueType = value.type[1]
-            for i in d.childRange():
+    pairType = value.type[4][0]
-                d.putPairItem(i, valueCCorNot(node["__value_"]))
+
-                node = node["__next_"]
+    if d.isExpanded():
+        curr = value["__table_"]["__p1_"].split("pp")[0]
+
+        def traverse_list(node):
+            while node:
+                (next_, _, pad, pair) = d.split("pp@{%s}" % (pairType.name), node)
+                yield pair.split("{%s}@{%s}" % (keyType.name, valueType.name))[::2]
+                node = next_
+
+        with Children(d, size, childType=value.type[0], maxNumChild=1000):
+            for (i, value) in zip(d.childRange(), traverse_list(curr)):
+                d.putPairItem(i, value, 'key', 'value')
 
 
 def qdump__std____1__unordered_set(d, value):
-    size = int(value["__table_"]["__p2_"]["__first_"])
+    (size, _) = value["__table_"]["__p2_"].split("pp")
     d.putItemCount(size)
+
+    valueType = value.type[0]
+
     if d.isExpanded():
-        node = value["__table_"]["__p1_"]["__first_"]["__next_"]
+        curr = value["__table_"]["__p1_"].split("pp")[0]
+
+        def traverse_list(node):
+            while node:
+                (next_, _, pad, val) = d.split("pp@{%s}" % (valueType.name), node)
+                yield val
+                node = next_
+
         with Children(d, size, childType=value.type[0], maxNumChild=1000):
-            for i in d.childRange():
+            for (i, value) in zip(d.childRange(), traverse_list(curr)):
-                d.putSubItem(i, node["__value_"])
+                d.putSubItem(i, value)
-                node = node["__next_"]
 
 
 def qdump__std____debug__unordered_set(d, value):