def qdumpHelper__std__tree__iterator(d, value, isSet=False):
treeTypeName = None
if value.type.name.endswith("::iterator"):
treeTypeName = value.type.name[:-len("::iterator")]
elif value.type.name.endswith("::const_iterator"):
treeTypeName = value.type.name[:-len("::const_iterator")]
treeType = d.lookupType(treeTypeName) if treeTypeName else value.type[0]
keyType = treeType[0]
valueType = treeType[1]
node = value["_M_node"].dereference() # std::_Rb_tree_node_base
d.putExpandable()
d.putEmptyValue()
if d.isExpanded():
with Children(d):
if isSet:
typecode = 'pppp@{%s}' % keyType.name
(color, parent, left, right, pad1, key) = d.split(typecode, node)
d.putSubItem("value", key)
else:
typecode = 'pppp@{%s}@{%s}' % (keyType.name, valueType.name)
(color, parent, left, right, pad1, key, pad2, value) = d.split(typecode, node)
d.putSubItem("first", key)
d.putSubItem("second", value)
with SubItem(d, "[node]"):
d.putExpandable()
d.putEmptyValue()
d.putType(" ")
if d.isExpanded():
with Children(d):
#d.putSubItem("color", color)
nodeType = node.type.pointer()
d.putSubItem("left", d.createValue(left, nodeType))
d.putSubItem("right", d.createValue(right, nodeType))
d.putSubItem("parent", d.createValue(parent, nodeType))
def qdump__cv__Mat(d, value):
(flag, dims, rows, cols, data, refcount, datastart, dataend,
datalimit, allocator, size, stepp) \
= value.split('iiiipppppppp')
steps = d.split('p' * dims, stepp)
innerSize = 0 if dims == 0 else steps[dims - 1]
if dims != 2:
d.putEmptyValue()
d.putPlainChildren(value)
return
if d.currentItemFormat() == DisplayFormat.SeparateFormat:
rs = steps[0] * innerSize
cs = cols * innerSize
dform = 'arraydata:separate:int:%d::2:%d:%d' % (innerSize, cols, rows)
out = ''.join(d.readMemory(data + i * rs, cs) for i in range(rows))
d.putDisplay(dform, out)
d.putValue('(%s x %s)' % (rows, cols))
if d.isExpanded():
with Children(d):
innerType = d.createType(TypeCode.TypeCodeIntegral, innerSize)
for i in range(rows):
for j in range(cols):
with SubItem(d, None):
d.putName('[%d,%d]' % (i, j))
addr = data + (i * steps[0] + j) * innerSize
d.putItem(d.createValue(addr, innerType))
def qdump__Utils__NameValueDictionary(d, value):
dptr = d.extractPointer(value["m_values"])
(ref, n) = d.split('ii', dptr)
d.check(0 <= n and n <= 100 * 1000 * 1000)
d.check(-1 <= ref and ref < 100000)
d.putItemCount(n)
if d.isExpanded():
if n > 10000:
n = 10000
typeCode = 'ppp@{%s}@{%s}' % ("Utils::DictKey", "QString")
def helper(node):
(p, left, right, padding1, key, padding2, value) = d.split(typeCode, node)
if left:
for res in helper(left):
yield res
yield (key["name"], value)
if right:
for res in helper(right):
yield res
with Children(d, n):
for (pair, i) in zip(helper(dptr + 8), range(n)):
d.putPairItem(i, pair, 'key', 'value')
def qdump__std__set__QNX(d, value):
try:
_ = value["_Mypair"]["_Myval2"]["_Myval2"]["_Myproxy"]
(proxy, head, size) = value.split("ppp")
except Exception:
(head, size) = value.split("pp")
d.check(0 <= size and size <= 100 * 1000 * 1000)
d.putItemCount(size)
if d.isExpanded():
childType = value.type[0]
def helper(node):
(left, parent, right, color, isnil, pad,
value) = d.split("pppcc@{%s}" % childType.name, node)
if left != head:
for res in helper(left):
yield res
yield value
if right != head:
for res in helper(right):
yield res
(smallest, root) = d.split("pp", head)
with Children(d, size, maxNumChild=1000):
for (item, i) in zip(helper(root), d.childRange()):
d.putSubItem(i, item)
def qdump__std____1__map(d, value):
try:
(proxy, head, size) = value.split("ppp")
d.check(0 <= size and 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():
keyType = value.type[0]
valueType = value.type[1]
pairType = value.type[3][0]
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):
for (i, pair) in zip(d.childRange(), in_order_traversal(head)):
d.putPairItem(i, pair, 'key', 'value')
def qdump__std__map(d, value):
if d.isQnxTarget() or d.isMsvcTarget():
qdump_std__map__helper(d, value)
return
# stuff is actually (color, pad) with 'I@', but we can save cycles/
(compare, stuff, parent, left, right, size) = value.split('pppppp')
d.check(0 <= size and size <= 100*1000*1000)
d.putItemCount(size)
if d.isExpanded():
keyType = value.type[0]
valueType = value.type[1]
with Children(d, size, maxNumChild=1000):
node = value["_M_t"]["_M_impl"]["_M_header"]["_M_left"]
nodeSize = node.dereference().type.size()
typeCode = "@{%s}@{%s}" % (keyType.name, valueType.name)
for i in d.childRange():
(pad1, key, pad2, value) = d.split(typeCode, node.pointer() + nodeSize)
d.putPairItem(i, (key, value))
if node["_M_right"].pointer() == 0:
parent = node["_M_parent"]
while True:
if node.pointer() != parent["_M_right"].pointer():
break
node = parent
parent = parent["_M_parent"]
if node["_M_right"] != parent:
node = parent
else:
node = node["_M_right"]
while True:
if node["_M_left"].pointer() == 0:
break
node = node["_M_left"]
def qdump__std____1__map__iterator(d, value):
d.putEmptyValue()
if d.isExpanded():
with Children(d):
node = value['__i_']['__ptr_'].dereference()['__value_']['__cc']
d.putSubItem('first', node['first'])
d.putSubItem('second', node['second'])
def qdump_std__map__helper(d, value):
try:
_ = value["_Mypair"]["_Myval2"]["_Myval2"]["_Myproxy"]
(proxy, head, size) = value.split("ppp")
except Exception:
(head, size) = value.split("pp")
d.check(0 <= size and size <= 100 * 1000 * 1000)
d.putItemCount(size)
if d.isExpanded():
keyType = value.type[0]
valueType = value.type[1]
pairType = value.type[3][0]
def helper(node):
(left, parent, right, color, isnil, pad,
pair) = d.split("pppcc@{%s}" % (pairType.name), node)
if left != head:
for res in helper(left):
yield res
yield pair.split("{%s}@{%s}" % (keyType.name, valueType.name))[::2]
if right != head:
for res in helper(right):
yield res
(smallest, root) = d.split("pp", head)
with Children(d, size, maxNumChild=1000):
for (pair, i) in zip(helper(root), d.childRange()):
d.putPairItem(i, pair)
def qdump__std__list(d, value):
if d.isQnxTarget() or d.isMsvcTarget():
qdump__std__list__QNX(d, value)
return
if value.type.size() == 3 * d.ptrSize():
# C++11 only.
(dummy1, dummy2, size) = value.split("ppp")
d.putItemCount(size)
else:
# Need to count manually.
p = d.extractPointer(value)
head = value.address()
size = 0
while head != p and size < 1001:
size += 1
p = d.extractPointer(p)
d.putItemCount(size, 1000)
if d.isExpanded():
p = d.extractPointer(value)
innerType = value.type[0]
with Children(d, size, maxNumChild=1000, childType=innerType):
for i in d.childRange():
d.putSubItem(i, d.createValue(p + 2 * d.ptrSize(), innerType))
p = d.extractPointer(p)
def qdump__std__deque__QNX(d, value):
innerType = value.type[0]
innerSize = innerType.size()
if innerSize <= 1:
bufsize = 16
elif innerSize <= 2:
bufsize = 8
elif innerSize <= 4:
bufsize = 4
elif innerSize <= 8:
bufsize = 2
else:
bufsize = 1
try:
val = value['_Mypair']['_Myval2']
except:
val = value
myoff = val['_Myoff'].integer()
mysize = val['_Mysize'].integer()
mapsize = val['_Mapsize'].integer()
d.check(0 <= mapsize and mapsize <= 1000 * 1000 * 1000)
d.putItemCount(mysize)
if d.isExpanded():
with Children(d, mysize, maxNumChild=2000, childType=innerType):
map = val['_Map']
for i in d.childRange():
block = myoff / bufsize
offset = myoff - (block * bufsize)
if mapsize <= block:
block -= mapsize
d.putSubItem(i, map[block][offset])
myoff += 1
def qdump__std__deque__MSVC(d, value):
innerType = value.type[0]
innerSize = innerType.size()
if innerSize <= 1:
bufsize = 16
elif innerSize <= 2:
bufsize = 8
elif innerSize <= 4:
bufsize = 4
elif innerSize <= 8:
bufsize = 2
else:
bufsize = 1
(proxy, map, mapsize, myoff, mysize) = value.split("ppppp")
d.check(0 <= mapsize and mapsize <= 1000 * 1000 * 1000)
d.putItemCount(mysize)
if d.isExpanded():
with Children(d, mysize, maxNumChild=2000, childType=innerType):
for i in d.childRange():
if myoff >= bufsize * mapsize:
myoff = 0
buf = map + ((myoff // bufsize) * d.ptrSize())
address = d.extractPointer(buf) + (
(myoff % bufsize) * innerSize)
d.putSubItem(i, d.createValue(address, innerType))
myoff += 1
def qdumpHelper__std__deque__libstdcxx(d, value):
innerType = value.type[0]
innerSize = innerType.size()
bufsize = 1
if innerSize < 512:
bufsize = 512 // innerSize
(mapptr, mapsize, startCur, startFirst, startLast, startNode, finishCur,
finishFirst, finishLast, finishNode) = value.split("pppppppppp")
size = bufsize * ((finishNode - startNode) // d.ptrSize() - 1)
size += (finishCur - finishFirst) // innerSize
size += (startLast - startCur) // innerSize
d.check(0 <= size and size <= 1000 * 1000 * 1000)
d.putItemCount(size)
if d.isExpanded():
with Children(d, size, maxNumChild=2000, childType=innerType):
pcur = startCur
plast = startLast
pnode = startNode
for i in d.childRange():
d.putSubItem(i, d.createValue(pcur, innerType))
pcur += innerSize
if pcur == plast:
newnode = pnode + d.ptrSize()
pfirst = d.extractPointer(newnode)
plast = pfirst + bufsize * d.ptrSize()
pcur = pfirst
pnode = newnode
def qdumpHelper__std__vector__QNX(d, value):
innerType = value.type[0]
isBool = innerType.name == 'bool'
if isBool:
(proxy1, proxy2, start, last, end, size) = value.split("pppppi")
else:
(proxy, start, last, end) = value.split("pppp")
size = (last - start) // innerType.size()
d.check(0 <= size and size <= 1000 * 1000 * 1000)
d.check(last <= end)
if size > 0:
d.checkPointer(start)
d.checkPointer(last)
d.checkPointer(end)
d.putItemCount(size)
if d.isExpanded():
if isBool:
with Children(d, size, maxNumChild=10000, childType=innerType):
for i in d.childRange():
q = start + int(i / 8)
with SubItem(d, i):
d.putValue((d.extractPointer(q) >> (i % 8)) & 1)
d.putType("bool")
else:
d.putPlotData(start, size, innerType)
def qdump__std____1__set(d, value):
(proxy, head, size) = value.split("ppp")
d.check(0 <= size and size <= 100 * 1000 * 1000)
d.putItemCount(size)
if d.isExpanded():
valueType = value.type[0]
def in_order_traversal(node):
(left, right, parent, color, pad,
data) = d.split("pppB@{%s}" % (valueType.name), node)
if left:
for res in in_order_traversal(left):
yield res
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__QtcDumperTest_PointerArray(d, value):
foos = value["foos"]
d.putItemCount(10)
if d.isExpanded():
with Children(d, 10):
for i in d.childRange():
d.putSubItem(i, foos[i])
def qdump__std__set(d, value):
if d.isQnxTarget() or d.isMsvcTarget():
qdump__std__set__QNX(d, value)
return
impl = value["_M_t"]["_M_impl"]
size = impl["_M_node_count"].integer()
d.check(0 <= size and size <= 100 * 1000 * 1000)
d.putItemCount(size)
if d.isExpanded():
valueType = value.type[0]
node = impl["_M_header"]["_M_left"]
nodeSize = node.dereference().type.size()
typeCode = "@{%s}" % valueType.name
with Children(d, size, maxNumChild=1000, childType=valueType):
for i in d.childRange():
(pad, val) = d.split(typeCode, node.pointer() + nodeSize)
d.putSubItem(i, val)
if node["_M_right"].pointer() == 0:
parent = node["_M_parent"]
while node.pointer() == parent["_M_right"].pointer():
node = parent
parent = parent["_M_parent"]
if node["_M_right"] != parent:
node = parent
else:
node = node["_M_right"]
while node["_M_left"].pointer() != 0:
node = node["_M_left"]
def qdump____m512i(d, value):
data = d.hexencode(value.data(64))
d.putValue(':'.join('%04x' % int(data[i:i+4], 16) for i in range(0, 64, 4))
+ ', ' + ':'.join('%04x' % int(data[i:i+4], 16) for i in range(64, 128, 4)))
if d.isExpanded():
with Children(d):
d.putArrayItem('uint32x16', value.address(), 16, 'unsigned int')
d.putArrayItem('uint64x8', value.address(), 8, 'unsigned long long')
def qdump__tree(d, value):
count = value['count']
entries = value['entries']
base = value['base'].pointer()
d.putItemCount(count)
if d.isExpanded():
with Children(d):
with SubItem(d, 'tree'):
d.putEmptyValue()
d.putNoType()
if d.isExpanded():
with Children(d):
for i in range(count):
d.putSubItem(Item(entries[i], iname))
with SubItem(d, 'data'):
d.putEmptyValue()
d.putNoType()
if d.isExpanded():
with Children(d):
for i in range(count):
with SubItem(d, i):
entry = entries[i]
mpitype = str(entry['type'])
d.putType(mpitype)
length = int(entry['blocklength'])
offset = int(entry['offset'])
d.putValue('%s items at %s' %
(length, offset))
if mpitype == 'MPI_INT':
innerType = 'int'
elif mpitype == 'MPI_CHAR':
innerType = 'char'
elif mpitype == 'MPI_DOUBLE':
innerType = 'double'
else:
length = 0
d.putNumChild(length)
if d.isExpanded():
with Children(d):
t = d.lookupType(
innerType).pointer()
p = (base + offset).cast(t)
for j in range(length):
d.putSubItem(
j, p.dereference())
def qdump__std__complex(d, value):
innerType = value.type[0]
(real, imag) = value.split('{%s}{%s}' % (innerType.name, innerType.name))
d.putValue("(%s, %s)" % (real.display(), imag.display()))
d.putExpandable()
if d.isExpanded():
with Children(d, 2, childType=innerType):
d.putSubItem("real", real)
d.putSubItem("imag", imag)
def qdump__System__Drawing__Size(d, value):
w, h = value.split('ii')
d.putValue('Width = %d Height = %d' % (w, h))
d.putExpandable()
if d.isExpanded():
with Children(d):
d.putBoolItem('IsEmpty', w == 0 and h == 0)
d.putIntItem('Width', w)
d.putIntItem('Heigth', h)
def qdump__System__Drawing__PointF(d, value):
x, y = value.split('ff')
d.putValue('X = %g Y = %g' % (x, y))
d.putExpandable()
if d.isExpanded():
with Children(d):
d.putBoolItem('IsEmpty', x == 0 and y == 0)
putFloatItem(d, 'X', x)
putFloatItem(d, 'Y', y)
def qdump__System__Drawing__Point(d, value):
x, y = value.split('ii')
d.putValue('X = %d Y = %d' % (x, y))
d.putExpandable()
if d.isExpanded():
with Children(d):
d.putBoolItem('IsEmpty', x == 0 and y == 0)
d.putIntItem('X', x)
d.putIntItem('Y', y)
def qdump__QtcDumperTest_List(d, value):
innerType = value.type[0]
d.putExpandable()
p = value['root']
if d.isExpanded():
with Children(d):
d.putSubItem("[p]", p)
d.putSubItem("[root]", value["root"].cast(innerType))
d.putFields(value)
def qdump__System__Drawing__SizeF(d, value):
w, h = value.split('ff')
d.putValue('Width = %g Height = %g' % (w, h))
d.putExpandable()
if d.isExpanded():
with Children(d):
d.putBoolItem('IsEmpty', w == 0 and h == 0)
putFloatItem(d, 'Width', w)
putFloatItem(d, 'Heigth', h)
def qdump__std__pair(d, value):
typeCode = '{%s}@{%s}' % (value.type[0].name, value.type[1].name)
first, pad, second = value.split(typeCode)
with Children(d):
key = d.putSubItem('first', first)
value = d.putSubItem('second', second)
key = key.value if key.encoding is None else "..."
value = value.value if value.encoding is None else "..."
d.putValue('(%s, %s)' % (key, value))
def qdump____m256i(d, value):
data = d.hexencode(value.data(32))
d.putValue(':'.join('%04x' % int(data[i:i+4], 16) for i in range(0, 64, 4)))
if d.isExpanded():
with Children(d):
addr = value.address()
d.putArrayItem('uint8x32', addr, 32, 'unsigned char')
d.putArrayItem('uint16x16', addr, 16, 'unsigned short')
d.putArrayItem('uint32x8', addr, 8, 'unsigned int')
d.putArrayItem('uint64x4', addr, 4, 'unsigned long long')
def qdumpHelper__std__vector__bool(d, start, size, inner_type):
d.check(0 <= size and size <= 1000 * 1000 * 1000)
d.putItemCount(size)
if d.isExpanded():
with Children(d, size, maxNumChild=10000, childType=inner_type):
for i in d.childRange():
q = start + int(i / 8)
with SubItem(d, i):
d.putValue((int(d.extractPointer(q)) >> (i % 8)) & 1)
d.putType("bool")
def qdump__std__pair(d, value):
typeCode = '{%s}@{%s}' % (value.type[0].name, value.type[1].name)
first, pad, second = value.split(typeCode)
with Children(d):
key = d.putSubItem('first', first)
value = d.putSubItem('second', second)
d.putField('key', key.value)
if key.encoding is not None:
d.putField('keyencoded', key.encoding)
d.putValue(value.value, value.encoding)
def qdump__std__variant(d, value):
which = int(value["_M_index"])
type = d.templateArgument(value.type, which)
d.putValue("<%s:%s>" % (which, type.name))
d.putNumChild(1)
if d.isExpanded():
storage = value["_M_u"]["_M_first"]["_M_storage"]
with Children(d, 1):
d.putSubItem("value", storage.cast(type))
def qdump__std__list__QNX(d, value):
(proxy, head, size) = value.split("ppp")
d.putItemCount(size, 1000)
if d.isExpanded():
p = d.extractPointer(head)
innerType = value.type[0]
with Children(d, size, maxNumChild=1000, childType=innerType):
for i in d.childRange():
d.putSubItem(i, d.createValue(p + 2 * d.ptrSize(), innerType))
p = d.extractPointer(p)
