feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Debugger: Report full sizes instead of the elide setup

Browse Source 
More direct communication of the meaning. Use 'length' when talking
about things like string lengths, and 'size' for sizes in bytes.

Task-number:  QTCREATORBUG-30065
Change-Id: Ifed84a5dab4ed890973c1abf4d427655eb50a61a
Reviewed-by: David Schulz <david.schulz@qt.io>
This commit is contained in:
hjk
2024-02-13 14:58:56 +01:00
parent 02d930b210
commit a26aff7afd
6 changed files with 184 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
share/qtcreator/debugger/creatortypes.py
View File

@@ -204,7 +204,7 @@ def qdump__CPlusPlus__Internal__Value(d, value):
def qdump__Utils__FilePath(d, value):
data, path_len, scheme_len, host_len = d.split("{@QString}IHH", value)
elided, enc = d.encodeStringHelper(data, d.displayStringLimit)
length, enc = d.encodeStringHelper(data, d.displayStringLimit)
# enc is concatenated path + scheme + host
if scheme_len:
scheme_pos = path_len * 4
@@ -221,7 +221,7 @@ def qdump__Utils__FilePath(d, value):
val += path_enc
else:
val = enc
d.putValue(val, "utf16", elided=elided)
d.putValue(val, "utf16", length=length)
d.putPlainChildren(value)

179
share/qtcreator/debugger/dumper.py
View File

@@ -44,15 +44,15 @@ class ReportItem():
subsequent better guesses during a putItem() run.
"""
def __init__(self, value=None, encoding=None, priority=-100, elided=None):
def __init__(self, value=None, encoding=None, priority=-100, length=None):
self.value = value
self.priority = priority
self.encoding = encoding
self.elided = elided
self.length = length
def __str__(self):
return 'Item(value: %s, encoding: %s, priority: %s, elided: %s)' \
% (self.value, self.encoding, self.priority, self.elided)
return 'Item(value: %s, encoding: %s, priority: %s, length: %s)' \
% (self.value, self.encoding, self.priority, self.length)
class Timer():
@@ -349,8 +349,8 @@ class DumperBase():
else:
if self.currentValue.encoding is not None:
self.put('valueencoded="%s",' % self.currentValue.encoding)
if self.currentValue.elided:
self.put('valueelided="%s",' % self.currentValue.elided)
if self.currentValue.length:
self.put('valuelen="%s",' % self.currentValue.length)
self.put('value="%s",' % self.currentValue.value)
except:
pass
@@ -376,7 +376,7 @@ class DumperBase():
b = bytes(bytearray.fromhex(value))
value = codecs.decode(b, 'utf-16')
self.put('"%s"' % value)
if self.currentValue.elided:
if self.currentValue.length:
self.put('...')
if self.currentType.value:
@@ -545,40 +545,40 @@ class DumperBase():
# assume no Qt 3 support by default
return False
# Clamps size to limit.
def computeLimit(self, size, limit):
# Clamps length to limit.
def computeLimit(self, length, limit=0):
if limit == 0:
limit = self.displayStringLimit
if limit is None or size <= limit:
return 0, size
return size, limit
if limit is None or length <= limit:
return length
return limit
def vectorData(self, value):
if self.qtVersion() >= 0x060000:
data, size, alloc = self.qArrayData(value)
data, length, alloc = self.qArrayData(value)
elif self.qtVersion() >= 0x050000:
vector_data_ptr = self.extractPointer(value)
if self.ptrSize() == 4:
(ref, size, alloc, offset) = self.split('IIIp', vector_data_ptr)
(ref, length, alloc, offset) = self.split('IIIp', vector_data_ptr)
else:
(ref, size, alloc, pad, offset) = self.split('IIIIp', vector_data_ptr)
(ref, length, alloc, pad, offset) = self.split('IIIIp', vector_data_ptr)
alloc = alloc & 0x7ffffff
data = vector_data_ptr + offset
else:
vector_data_ptr = self.extractPointer(value)
(ref, alloc, size) = self.split('III', vector_data_ptr)
(ref, alloc, length) = self.split('III', vector_data_ptr)
data = vector_data_ptr + 16
self.check(0 <= size and size <= alloc and alloc <= 1000 * 1000 * 1000)
return data, size
self.check(0 <= length and length <= alloc and alloc <= 1000 * 1000 * 1000)
return data, length
def qArrayData(self, value):
if self.qtVersion() >= 0x60000:
dd, data, size = self.split('ppp', value)
dd, data, length = self.split('ppp', value)
if dd:
_, _, alloc = self.split('iip', dd)
else: # fromRawData
alloc = size
return data, size, alloc
alloc = length
return data, length, alloc
return self.qArrayDataHelper(self.extractPointer(value))
def qArrayDataHelper(self, array_data_ptr):
@@ -586,10 +586,10 @@ class DumperBase():
if self.qtVersion() >= 0x050000:
# QTypedArray:
# - QtPrivate::RefCount ref
# - int size
# - int length
# - uint alloc : 31, capacityReserved : 1
# - qptrdiff offset
(ref, size, alloc, offset) = self.split('IIpp', array_data_ptr)
(ref, length, alloc, offset) = self.split('IIpp', array_data_ptr)
alloc = alloc & 0x7ffffff
data = array_data_ptr + offset
if self.ptrSize() == 4:
@@ -599,43 +599,42 @@ class DumperBase():
elif self.qtVersion() >= 0x040000:
# Data:
# - QBasicAtomicInt ref;
# - int alloc, size;
# - int alloc, length;
# - [padding]
# - char *data;
if self.ptrSize() == 4:
(ref, alloc, size, data) = self.split('IIIp', array_data_ptr)
(ref, alloc, length, data) = self.split('IIIp', array_data_ptr)
else:
(ref, alloc, size, pad, data) = self.split('IIIIp', array_data_ptr)
(ref, alloc, length, pad, data) = self.split('IIIIp', array_data_ptr)
else:
# Data:
# - QShared count;
# - QChar *unicode
# - char *ascii
# - uint len: 30
(dummy, dummy, dummy, size) = self.split('IIIp', array_data_ptr)
size = self.extractInt(array_data_ptr + 3 * self.ptrSize()) & 0x3ffffff
alloc = size # pretend.
(dummy, dummy, dummy, length) = self.split('IIIp', array_data_ptr)
length = self.extractInt(array_data_ptr + 3 * self.ptrSize()) & 0x3ffffff
alloc = length # pretend.
data = self.extractPointer(array_data_ptr + self.ptrSize())
return data, size, alloc
return data, length, alloc
def encodeStringHelper(self, value, limit):
data, size, alloc = self.qArrayData(value)
data, length, alloc = self.qArrayData(value)
if alloc != 0:
self.check(0 <= size and size <= alloc and alloc <= 100 * 1000 * 1000)
elided, shown = self.computeLimit(2 * size, 2 * limit)
return elided, self.readMemory(data, shown)
self.check(0 <= length and length <= alloc and alloc <= 100 * 1000 * 1000)
shown = self.computeLimit(2 * length, 2 * limit)
return length, self.readMemory(data, shown)
def encodeByteArrayHelper(self, value, limit):
data, size, alloc = self.qArrayData(value)
data, length, alloc = self.qArrayData(value)
if alloc != 0:
self.check(0 <= size and size <= alloc and alloc <= 100 * 1000 * 1000)
elided, shown = self.computeLimit(size, limit)
return elided, self.readMemory(data, shown)
self.check(0 <= length and length <= alloc and alloc <= 100 * 1000 * 1000)
shown = self.computeLimit(length, limit)
return length, self.readMemory(data, shown)
def putCharArrayValue(self, data, size, charSize,
def putCharArrayValue(self, data, length, charSize,
displayFormat=DisplayFormat.Automatic):
bytelen = size * charSize
elided, shown = self.computeLimit(bytelen, self.displayStringLimit)
shown = self.computeLimit(length, self.displayStringLimit)
mem = self.readMemory(data, shown)
if charSize == 1:
if displayFormat in (DisplayFormat.Latin1String, DisplayFormat.SeparateLatin1String):
@@ -650,13 +649,13 @@ class DumperBase():
encodingType = 'ucs4'
#childType = 'int'
self.putValue(mem, encodingType, elided=elided)
self.putValue(mem, encodingType, length=length)
if displayFormat in (
DisplayFormat.SeparateLatin1String,
DisplayFormat.SeparateUtf8String,
DisplayFormat.Separate):
elided, shown = self.computeLimit(bytelen, 100000)
shown = self.computeLimit(length, 100000)
self.putDisplay(encodingType + ':separate', self.readMemory(data, shown))
def putCharArrayHelper(self, data, size, charType,
@@ -676,15 +675,15 @@ class DumperBase():
return self.hexencode(bytes(self.readRawMemory(addr, size)))
def encodeByteArray(self, value, limit=0):
elided, data = self.encodeByteArrayHelper(value, limit)
_, data = self.encodeByteArrayHelper(value, limit)
return data
def putByteArrayValue(self, value):
elided, data = self.encodeByteArrayHelper(value, self.displayStringLimit)
self.putValue(data, 'latin1', elided=elided)
length, data = self.encodeByteArrayHelper(value, self.displayStringLimit)
self.putValue(data, 'latin1', length=length)
def encodeString(self, value, limit=0):
elided, data = self.encodeStringHelper(value, limit)
_, data = self.encodeStringHelper(value, limit)
return data
def encodedUtf16ToUtf8(self, s):
@@ -730,8 +729,8 @@ class DumperBase():
return inner
def putStringValue(self, value):
elided, data = self.encodeStringHelper(value, self.displayStringLimit)
self.putValue(data, 'utf16', elided=elided)
length, data = self.encodeStringHelper(value, self.displayStringLimit)
self.putValue(data, 'utf16', length=length)
def putPtrItem(self, name, value):
with SubItem(self, name):
@@ -900,12 +899,12 @@ class DumperBase():
if not self.isInt(thing):
raise RuntimeError('Expected an integral value, got %s' % type(thing))
def readToFirstZero(self, base, tsize, maximum):
def readToFirstZero(self, base, typesize, maximum):
self.checkIntType(base)
self.checkIntType(tsize)
self.checkIntType(typesize)
self.checkIntType(maximum)
code = self.packCode + (None, 'b', 'H', None, 'I')[tsize]
code = self.packCode + (None, 'b', 'H', None, 'I')[typesize]
#blob = self.readRawMemory(base, 1)
blob = bytes()
while maximum > 1:
@@ -916,8 +915,8 @@ class DumperBase():
maximum = int(maximum / 2)
self.warn('REDUCING READING MAXIMUM TO %s' % maximum)
#DumperBase.warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, tsize, maximum))
for i in range(0, maximum, tsize):
#DumperBase.warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, typesize, maximum))
for i in range(0, maximum, typesize):
t = struct.unpack_from(code, blob, i)[0]
if t == 0:
return 0, i, self.hexencode(blob[:i])
@@ -925,9 +924,9 @@ class DumperBase():
# Real end is unknown.
return -1, maximum, self.hexencode(blob[:maximum])
def encodeCArray(self, p, tsize, limit):
elided, shown, blob = self.readToFirstZero(p, tsize, limit)
return elided, blob
def encodeCArray(self, p, typesize, limit):
length, shown, blob = self.readToFirstZero(p, typesize, limit)
return length, blob
def putItemCount(self, count, maximum=1000000000):
# This needs to override the default value, so don't use 'put' directly.
@@ -1043,12 +1042,12 @@ class DumperBase():
self.currentType.value = typish.name
self.currentType.priority = priority
def putValue(self, value, encoding=None, priority=0, elided=None):
def putValue(self, value, encoding=None, priority=0, length=None):
# Higher priority values override lower ones.
# elided = 0 indicates all data is available in value,
# length = None indicates all data is available in value,
# otherwise it's the true length.
if priority >= self.currentValue.priority:
self.currentValue = ReportItem(value, encoding, priority, elided)
self.currentValue = ReportItem(value, encoding, priority, length)
def putSpecialValue(self, encoding, value='', children=None):
self.putValue(value, encoding)
@@ -1226,13 +1225,13 @@ class DumperBase():
return False
def putSimpleCharArray(self, base, size=None):
if size is None:
elided, shown, data = self.readToFirstZero(base, 1, self.displayStringLimit)
def putSimpleCharArray(self, base, length=None):
if length is None:
length, shown, data = self.readToFirstZero(base, 1, self.displayStringLimit)
else:
elided, shown = self.computeLimit(int(size), self.displayStringLimit)
shown = self.computeLimit(length)
data = self.readMemory(base, shown)
self.putValue(data, 'latin1', elided=elided)
self.putValue(data, 'latin1', length=length)
def putDisplay(self, editFormat, value):
self.putField('editformat', editFormat)
@@ -1248,8 +1247,8 @@ class DumperBase():
if targetType.name in ('char', 'signed char', 'unsigned char', 'uint8_t', 'CHAR'):
# Use UTF-8 as default for char *.
self.putType(typeName)
(elided, shown, data) = self.readToFirstZero(ptr, 1, limit)
self.putValue(data, 'utf8', elided=elided)
(length, shown, data) = self.readToFirstZero(ptr, 1, limit)
self.putValue(data, 'utf8', length=length)
if self.isExpanded():
self.putArrayData(ptr, shown, innerType)
return True
@@ -1257,55 +1256,55 @@ class DumperBase():
if targetType.name in ('wchar_t', 'WCHAR'):
self.putType(typeName)
charSize = self.lookupType('wchar_t').size()
(elided, data) = self.encodeCArray(ptr, charSize, limit)
(length, data) = self.encodeCArray(ptr, charSize, limit)
if charSize == 2:
self.putValue(data, 'utf16', elided=elided)
self.putValue(data, 'utf16', length=length)
else:
self.putValue(data, 'ucs4', elided=elided)
self.putValue(data, 'ucs4', length=length)
return True
if displayFormat == DisplayFormat.Latin1String:
self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'latin1', elided=elided)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'latin1', length=length)
return True
if displayFormat == DisplayFormat.SeparateLatin1String:
self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'latin1', elided=elided)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'latin1', length=length)
self.putDisplay('latin1:separate', data)
return True
if displayFormat == DisplayFormat.Utf8String:
self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'utf8', elided=elided)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'utf8', length=length)
return True
if displayFormat == DisplayFormat.SeparateUtf8String:
self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'utf8', elided=elided)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'utf8', length=length)
self.putDisplay('utf8:separate', data)
return True
if displayFormat == DisplayFormat.Local8BitString:
self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'local8bit', elided=elided)
(length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'local8bit', length=length)
return True
if displayFormat == DisplayFormat.Utf16String:
self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 2, limit)
self.putValue(data, 'utf16', elided=elided)
(length, data) = self.encodeCArray(ptr, 2, limit)
self.putValue(data, 'utf16', length=length)
return True
if displayFormat == DisplayFormat.Ucs4String:
self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 4, limit)
self.putValue(data, 'ucs4', elided=elided)
(length, data) = self.encodeCArray(ptr, 4, limit)
self.putValue(data, 'ucs4', length=length)
return True
return False
@@ -2577,17 +2576,17 @@ class DumperBase():
def extractQStringFromQDataStream(self, buf, offset):
""" Read a QString from the stream """
size = struct.unpack_from('!I', buf, offset)[0]
length = struct.unpack_from('!I', buf, offset)[0]
offset += 4
string = buf[offset:offset + size].decode('utf-16be')
return (string, offset + size)
string = buf[offset:offset + length].decode('utf-16be')
return (string, offset + length)
def extractQByteArrayFromQDataStream(self, buf, offset):
""" Read a QByteArray from the stream """
size = struct.unpack_from('!I', buf, offset)[0]
length = struct.unpack_from('!I', buf, offset)[0]
offset += 4
string = buf[offset:offset + size].decode('latin1')
return (string, offset + size)
string = buf[offset:offset + length].decode('latin1')
return (string, offset + length)
def extractIntFromQDataStream(self, buf, offset):
""" Read an int from the stream """

169
share/qtcreator/debugger/qttypes.py
View File

@@ -28,46 +28,46 @@ def qform__QByteArray():
def qedit__QByteArray(d, value, data):
d.call('void', value, 'resize', str(len(data)))
(base, size, alloc) = d.stringData(value)
(base, length, alloc) = d.stringData(value)
d.setValues(base, 'char', [ord(c) for c in data])
def qdump__QByteArray(d, value):
if d.qtVersion() >= 0x60000:
dd, data, size = value.split('ppi')
dd, data, length = value.split('ppi')
if dd:
_, _, alloc = d.split('iii', dd)
else: # fromRawData
alloc = size
alloc = length
else:
data, size, alloc = d.qArrayData(value)
data, length, alloc = d.qArrayData(value)
d.check(alloc == 0 or (0 <= size and size <= alloc and alloc <= 100000000))
if size > 0:
d.check(alloc == 0 or (0 <= length and length <= alloc and alloc <= 100000000))
if length > 0:
d.putExpandable()
elided, shown = d.computeLimit(size, d.displayStringLimit)
shown = d.computeLimit(length, d.displayStringLimit)
p = d.readMemory(data, shown)
displayFormat = d.currentItemFormat()
if displayFormat == DisplayFormat.Automatic or displayFormat == DisplayFormat.Latin1String:
d.putValue(p, 'latin1', elided=elided)
d.putValue(p, 'latin1', length=length)
elif displayFormat == DisplayFormat.SeparateLatin1String:
d.putValue(p, 'latin1', elided=elided)
d.putValue(p, 'latin1', length=length)
d.putDisplay('latin1:separate', d.encodeByteArray(value, limit=100000))
elif displayFormat == DisplayFormat.Utf8String:
d.putValue(p, 'utf8', elided=elided)
d.putValue(p, 'utf8', length=length)
elif displayFormat == DisplayFormat.SeparateUtf8String:
d.putValue(p, 'utf8', elided=elided)
d.putValue(p, 'utf8', length=length)
d.putDisplay('utf8:separate', d.encodeByteArray(value, limit=100000))
if d.isExpanded():
d.putArrayData(data, size, d.charType())
d.putArrayData(data, length, d.charType())
#def qdump__QArrayData(d, value):
# data, size, alloc = d.qArrayDataHelper(value.address())
# d.check(alloc == 0 or (0 <= size and size <= alloc and alloc <= 100000000))
# d.putValue(d.readMemory(data, size), 'latin1')
# data, length, alloc = d.qArrayDataHelper(value.address())
# d.check(alloc == 0 or (0 <= length and length <= alloc and alloc <= 100000000))
# d.putValue(d.readMemory(data, length), 'latin1')
# d.putPlainChildren(value)
@@ -81,10 +81,10 @@ def qdump__QBitArray(d, value):
else:
data, basize, _ = d.qArrayData(value['d'])
unused = d.extractByte(data) if data else 0
size = basize * 8 - unused
d.putItemCount(size)
length = basize * 8 - unused
d.putItemCount(length)
if d.isExpanded():
with Children(d, size, maxNumChild=10000):
with Children(d, length, maxNumChild=10000):
for i in d.childRange():
q = data + 1 + int(i / 8)
with SubItem(d, i):
@@ -1621,17 +1621,17 @@ def qdumpHelper_QSet45(d, value):
ptrSize = d.ptrSize()
dptr = d.extractPointer(value)
(fakeNext, buckets, ref, size, nodeSize, userNumBits, numBits, numBuckets) = \
(fakeNext, buckets, ref, length, nodeSize, userNumBits, numBits, numBuckets) = \
d.split('ppiiihhi', dptr)
d.check(0 <= size and size <= 100 * 1000 * 1000)
d.check(0 <= length and length <= 100 * 1000 * 1000)
d.check(-1 <= ref and ref < 100000)
d.putItemCount(size)
d.putItemCount(length)
if d.isExpanded():
keyType = value.type[0]
isShort = d.qtVersion() < 0x050000 and keyType.name == 'int'
with Children(d, size, childType=keyType):
with Children(d, length, childType=keyType):
node = hashDataFirstNode()
for i in d.childRange():
if isShort:
@@ -1714,15 +1714,15 @@ def qdump__QStack(d, value):
def qdump__QPolygonF(d, value):
data, size = d.vectorData(value)
d.putItemCount(size)
d.putPlotData(data, size, d.createType('@QPointF'))
data, length = d.vectorData(value)
d.putItemCount(length)
d.putPlotData(data, length, d.createType('@QPointF'))
def qdump__QPolygon(d, value):
data, size = d.vectorData(value)
d.putItemCount(size)
d.putPlotData(data, size, d.createType('@QPoint'))
data, length = d.vectorData(value)
d.putItemCount(length)
d.putPlotData(data, length, d.createType('@QPoint'))
def qdump__QGraphicsPolygonItem(d, value):
@@ -1741,14 +1741,14 @@ def qdump__QGraphicsPolygonItem(d, value):
offset = 328 if d.isMsvcTarget() else 320
else:
offset = 308
data, size = d.vectorData(dptr + offset)
d.putItemCount(size)
d.putPlotData(data, size, d.createType('@QPointF'))
data, length = d.vectorData(dptr + offset)
d.putItemCount(length)
d.putPlotData(data, length, d.createType('@QPointF'))
def qedit__QString(d, value, data):
d.call('void', value, 'resize', str(len(data)))
(base, size, alloc) = d.stringData(value)
(base, length, alloc) = d.stringData(value)
d.setValues(base, 'short', [ord(c) for c in data])
@@ -1758,14 +1758,14 @@ def qform__QString():
def qdump__QString(d, value):
d.putStringValue(value)
data, size, _ = d.stringData(value)
data, length, _ = d.stringData(value)
displayFormat = d.currentItemFormat()
if displayFormat == DisplayFormat.Separate:
d.putDisplay('utf16:separate', d.encodeString(value, limit=100000))
if (size > 0):
if (length > 0):
d.putExpandable()
if d.isExpanded():
d.putArrayData(data, size, d.createType('@QChar'))
d.putArrayData(data, length, d.createType('@QChar'))
def qdump__QSettingsKey(d, value):
@@ -1774,8 +1774,8 @@ def qdump__QSettingsKey(d, value):
def qdump__QStaticStringData(d, value):
size = value.type[0]
(ref, size, alloc, pad, offset, data) = value.split('iii@p%ss' % (2 * size))
length = value.type[0]
(ref, length, alloc, pad, offset, data) = value.split('iii@p%ss' % (2 * length))
d.putValue(d.hexencode(data), 'utf16')
d.putPlainChildren(value)
@@ -1788,28 +1788,28 @@ def qdump__QTypedArrayData(d, value):
def qdump__QStringData(d, value):
(ref, size, alloc, pad, offset) = value.split('III@p')
elided, shown = d.computeLimit(size, d.displayStringLimit)
(ref, length, alloc, pad, offset) = value.split('III@p')
shown = d.computeLimit(length, d.displayStringLimit)
data = d.readMemory(value.address() + offset, shown * 2)
d.putValue(data, 'utf16', elided=elided)
d.putValue(data, 'utf16', length=length)
d.putPlainChildren(value)
def qdump__QAnyStringView(d, value):
data, size = value.split('pp')
data, length = value.split('pp')
bits = d.ptrSize() * 8 - 2
tag = size >> bits
size = size & (2**bits - 1)
elided, shown = d.computeLimit(size, d.displayStringLimit)
tag = length >> bits
length = length & (2**bits - 1)
shown = d.computeLimit(length, d.displayStringLimit)
if tag == 0:
mem = d.readMemory(data, shown)
d.putValue(mem, 'utf8', elided=elided)
d.putValue(mem, 'utf8', length=length)
elif tag == 1:
mem = d.readMemory(data, shown)
d.putValue(mem, 'latin1', elided=elided)
d.putValue(mem, 'latin1', length=length)
elif tag == 2:
mem = d.readMemory(data, shown * 2)
d.putValue(mem, 'utf16', elided=elided)
d.putValue(mem, 'utf16', length=length)
else:
d.putSpecialValue('empty')
d.putPlainChildren(value)
@@ -1825,16 +1825,15 @@ def qdump__QStringView(d, value):
if idata == 0:
d.putValue('(null)')
return
size = value['m_size']
isize = size.integer()
elided, shown = d.computeLimit(isize, d.displayStringLimit)
length = value['m_size'].integer()
shown = d.computeLimit(length, d.displayStringLimit)
mem = d.readMemory(idata, shown * 2)
d.putValue(mem, 'utf16', elided=elided)
d.putValue(mem, 'utf16', length=length)
if d.currentItemFormat() == DisplayFormat.Separate:
d.putDisplay('utf16:separate', mem)
d.putExpandable()
if d.isExpanded():
d.putArrayData(idata, isize, d.createType('char16_t'))
d.putArrayData(idata, length, d.createType('char16_t'))
def qdump__QHashedString(d, value):
@@ -1848,12 +1847,12 @@ def qdump__QQmlRefCount(d, value):
def qdump__QStringRef(d, value):
(stringptr, pos, size) = value.split('pii')
(stringptr, pos, length) = value.split('pii')
if stringptr == 0:
d.putValue('(null)')
return
data, ssize, alloc = d.stringData(d.createValue(stringptr, '@QString'))
d.putValue(d.readMemory(data + 2 * pos, 2 * size), 'utf16')
d.putValue(d.readMemory(data + 2 * pos, 2 * length), 'utf16')
d.putPlainChildren(value)
@@ -1937,7 +1936,7 @@ def qdump__QUrl(d, value):
userNameEnc = d.encodeString(userName)
hostEnc = d.encodeString(host)
elided, pathEnc = d.encodeStringHelper(path, d.displayStringLimit)
length, pathEnc = d.encodeStringHelper(path, d.displayStringLimit)
url = d.encodeString(scheme)
url += '3a002f002f00' # '://'
if len(userNameEnc):
@@ -1946,7 +1945,7 @@ def qdump__QUrl(d, value):
if port >= 0:
url += '3a00' + ''.join(['%02x00' % ord(c) for c in str(port)])
url += pathEnc
d.putValue(url, 'utf16', elided=elided)
d.putValue(url, 'utf16', length=length)
displayFormat = d.currentItemFormat()
if displayFormat == DisplayFormat.Separate:
@@ -2162,7 +2161,7 @@ def qdumpHelper__QVariant6(d, value):
qdumpHelper_QVariant_0(d, value)
return
revision, alignment, size, flags, variantType, metaObjectPtr, name = \
revision, alignment, length, flags, variantType, metaObjectPtr, name = \
d.split('HHIIIpp', metaTypeInterface)
# Well-known simple type.
@@ -2241,7 +2240,7 @@ def qdumpHelper__QVariant45(d, value):
base1 = d.extractPointer(value)
#DumperBase.warn('BASE 1: %s %s' % (base1, innert))
base = d.extractPointer(base1)
#DumperBase.warn('SIZE 1: %s' % size)
#DumperBase.warn('SIZE 1: %s' % length)
val = d.createValue(base, innerType)
else:
#DumperBase.warn('DIRECT ITEM 1: %s' % innerType)
@@ -2268,7 +2267,7 @@ def qdumpHelper__QVariant45(d, value):
d.putSpecialValue('notcallable')
return None
ptr = p.pointer()
(elided, blob) = d.encodeCArray(ptr, 1, 100)
(_, blob) = d.encodeCArray(ptr, 1, 100)
innerType = d.hexdecode(blob)
# Prefer namespaced version.
@@ -2303,34 +2302,34 @@ def qform__QVector():
def qdump__QVector(d, value):
if d.qtVersion() >= 0x060000:
data, size = d.listData(value)
d.putItemCount(size)
d.putPlotData(data, size, d.createType(value.type.ltarget[0]))
data, length = d.listData(value)
d.putItemCount(length)
d.putPlotData(data, length, d.createType(value.type.ltarget[0]))
# g++ 9.3 does not add the template parameter list to the debug info.
# Fake it for the common case:
if value.type.name == d.qtNamespace() + "QVector":
d.putBetterType(value.type.name + '<' + value.type.ltarget[0].name + '>')
else:
data, size = d.vectorData(value)
d.putItemCount(size)
d.putPlotData(data, size, d.createType(value.type[0]))
data, length = d.vectorData(value)
d.putItemCount(length)
d.putPlotData(data, length, d.createType(value.type[0]))
if False:
def qdump__QObjectConnectionList(d, value):
data, size = d.vectorData(value)
d.putItemCount(size)
d.putPlotData(data, size, d.createType('@QObjectPrivate::ConnectionList'))
data, length = d.vectorData(value)
d.putItemCount(length)
d.putPlotData(data, length, d.createType('@QObjectPrivate::ConnectionList'))
def qdump__QVarLengthArray(d, value):
if d.qtVersion() >= 0x060000:
cap, size, data = value.split('QQp')
cap, length, data = value.split('QQp')
else:
cap, size, data = value.split('iip')
d.check(0 <= size)
d.putItemCount(size)
d.putPlotData(data, size, value.type[0])
cap, length, data = value.split('iip')
d.check(0 <= length)
d.putItemCount(length)
d.putPlotData(data, length, value.type[0])
def qdump__QSharedPointer(d, value):
@@ -2401,20 +2400,20 @@ def qdump__QXmlAttributes(d, value):
def qdump__QXmlStreamStringRef(d, value):
s = value['m_string']
(data, size, alloc) = d.stringData(s)
(data, length, alloc) = d.stringData(s)
data += 2 * int(value['m_position'])
size = int(value['m_size'])
s = d.readMemory(data, 2 * size)
length = int(value['m_size'])
s = d.readMemory(data, 2 * length)
d.putValue(s, 'utf16')
d.putPlainChildren(value)
def qdump__QXmlStreamAttribute(d, value):
s = value['m_name']['m_string']
(data, size, alloc) = d.stringData(s)
(data, length, alloc) = d.stringData(s)
data += 2 * int(value['m_name']['m_position'])
size = int(value['m_name']['m_size'])
s = d.readMemory(data, 2 * size)
length = int(value['m_name']['m_size'])
s = d.readMemory(data, 2 * length)
d.putValue(s, 'utf16')
d.putPlainChildren(value)
@@ -2505,8 +2504,8 @@ def qdump__QV4__ExecutionContext(d, value):
def qdump__QQmlSourceLocation(d, value):
(sourceFile, line, col) = value.split('pHH')
(data, size, alloc) = d.stringData(value)
d.putValue(d.readMemory(data, 2 * size), 'utf16')
(data, length, alloc) = d.stringData(value)
d.putValue(d.readMemory(data, 2 * length), 'utf16')
d.putField('valuesuffix', ':%s:%s' % (line, col))
d.putPlainChildren(value)
@@ -3345,9 +3344,7 @@ def qdump__QJsonValue(d, value):
return
if t == 3:
d.putType('QJsonValue (String)')
string = value.split('{@QString}')[0]
elided, base = d.encodeString(string, d.displayStringLimit)
d.putValue(base, 'utf16', elided=elided)
d.putStringValue(value.split('{@QString}')[0])
return
if t == 4:
d.putType('QJsonValue (Array)')
@@ -3472,9 +3469,9 @@ def qdumpHelper_QCbor_string(d, container_ptr, element_index, is_bytes):
bytedata_len = d.extractInt(bytedata)
bytedata_data = bytedata + 4 # sizeof(QtCbor::ByteData) header part
elided, shown = d.computeLimit(bytedata_len, d.displayStringLimit)
shown = d.computeLimit(bytedata_len, d.displayStringLimit)
res = d.readMemory(bytedata_data, shown)
d.putValue(res, enc, elided=elided)
d.putValue(res, enc, length=bytedata_len)
def qdumpHelper_QCborArray_valueAt(d, container_ptr, elements_data_ptr, idx, bytedata, is_cbor):

8
src/plugins/debugger/watchdata.cpp
View File

@@ -151,8 +151,8 @@ QString WatchItem::toString() const
if (!value.isEmpty())
str << "value=\"" << value << doubleQuoteComma;
if (elided)
str << "valueelided=\"" << elided << doubleQuoteComma;
if (valuelen)
str << "valuelen=\"" << valuelen << doubleQuoteComma;
if (!editvalue.isEmpty())
str << "editvalue=\"<...>\",";
@@ -300,9 +300,9 @@ void WatchItem::parseHelper(const GdbMi &input, bool maySort)
if (mi.isValid())
id = mi.toInt();
mi = input["valueelided"];
mi = input["valuelen"];
if (mi.isValid())
elided = mi.toInt();
valuelen = mi.toInt();
mi = input["bitpos"];
if (mi.isValid())

2
src/plugins/debugger/watchdata.h
View File

@@ -72,7 +72,7 @@ public:
uint bitsize = 0; // Size in case of bit fields
uint autoDerefCount = 0; // number of levels of automatic dereferencing that has taken place (for pointer types)
uint variablesReference = 0;// reference to the variable in the variables request DAP related
int elided = 0; // Full size if value was cut off, -1 if cut on unknown size, 0 otherwise
int valuelen = 0; // -1 if cut on unknown size, full size otherwise
int arrayIndex = -1; // -1 if not an array member
uchar sortGroup = 0; // 0 - ordinary member, 1 - vptr, 2 - base class
bool wantsChildren = false;

10
src/plugins/debugger/watchhandler.cpp
View File

@@ -822,12 +822,12 @@ static QString formattedValue(const WatchItem *item)
QString v = quoteUnprintable(item->value);
if (v.endsWith('"')) {
if (item->elided) {
if (item->valuelen > maxLength) {
v.chop(1);
v.append("...\"");
}
int len = item->elided ? item->elided : item->value.length() - 2;
v += QString(" (%1)").arg(len > 0 ? QString::number(len) : "unknown length");
if (item->valuelen > 0)
v += QString(" (%1)").arg(item->valuelen);
return v;
}
@@ -1297,7 +1297,7 @@ Qt::ItemFlags WatchModel::flags(const QModelIndex &idx) const
// FIXME: Forcing types is not implemented yet.
//if (idx.column() == 2)
// return editable; // Watcher types can be set by force.
if (column == ValueColumn && item->valueEditable && !item->elided)
if (column == ValueColumn && item->valueEditable && item->valuelen >= 0)
return editable; // Watcher values are sometimes editable.
}
} else if (item->isLocal()) {
@@ -1305,7 +1305,7 @@ Qt::ItemFlags WatchModel::flags(const QModelIndex &idx) const
return notEditable;
if (isRunning && !m_engine->hasCapability(AddWatcherWhileRunningCapability))
return notEditable;
if (column == ValueColumn && item->valueEditable && !item->elided)
if (column == ValueColumn && item->valueEditable && item->valuelen >= 0)
return editable; // Locals values are sometimes editable.
if (column == ValueColumn && item->arrayIndex >= 0)
return editable;