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

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

@@ -44,15 +44,15 @@ class ReportItem():
subsequent better guesses during a putItem() run. 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.value = value
self.priority = priority self.priority = priority
self.encoding = encoding self.encoding = encoding
self.elided = elided self.length = length
def __str__(self): def __str__(self):
return 'Item(value: %s, encoding: %s, priority: %s, elided: %s)' \ return 'Item(value: %s, encoding: %s, priority: %s, length: %s)' \
% (self.value, self.encoding, self.priority, self.elided) % (self.value, self.encoding, self.priority, self.length)
class Timer(): class Timer():
@@ -349,8 +349,8 @@ class DumperBase():
else: else:
if self.currentValue.encoding is not None: if self.currentValue.encoding is not None:
self.put('valueencoded="%s",' % self.currentValue.encoding) self.put('valueencoded="%s",' % self.currentValue.encoding)
if self.currentValue.elided: if self.currentValue.length:
self.put('valueelided="%s",' % self.currentValue.elided) self.put('valuelen="%s",' % self.currentValue.length)
self.put('value="%s",' % self.currentValue.value) self.put('value="%s",' % self.currentValue.value)
except: except:
pass pass
@@ -376,7 +376,7 @@ class DumperBase():
b = bytes(bytearray.fromhex(value)) b = bytes(bytearray.fromhex(value))
value = codecs.decode(b, 'utf-16') value = codecs.decode(b, 'utf-16')
self.put('"%s"' % value) self.put('"%s"' % value)
if self.currentValue.elided: if self.currentValue.length:
self.put('...') self.put('...')
if self.currentType.value: if self.currentType.value:
@@ -545,40 +545,40 @@ class DumperBase():
# assume no Qt 3 support by default # assume no Qt 3 support by default
return False return False
# Clamps size to limit. # Clamps length to limit.
def computeLimit(self, size, limit): def computeLimit(self, length, limit=0):
if limit == 0: if limit == 0:
limit = self.displayStringLimit limit = self.displayStringLimit
if limit is None or size <= limit: if limit is None or length <= limit:
return 0, size return length
return size, limit return limit
def vectorData(self, value): def vectorData(self, value):
if self.qtVersion() >= 0x060000: if self.qtVersion() >= 0x060000:
data, size, alloc = self.qArrayData(value) data, length, alloc = self.qArrayData(value)
elif self.qtVersion() >= 0x050000: elif self.qtVersion() >= 0x050000:
vector_data_ptr = self.extractPointer(value) vector_data_ptr = self.extractPointer(value)
if self.ptrSize() == 4: 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: 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 alloc = alloc & 0x7ffffff
data = vector_data_ptr + offset data = vector_data_ptr + offset
else: else:
vector_data_ptr = self.extractPointer(value) 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 data = vector_data_ptr + 16
self.check(0 <= size and size <= alloc and alloc <= 1000 * 1000 * 1000) self.check(0 <= length and length <= alloc and alloc <= 1000 * 1000 * 1000)
return data, size return data, length
def qArrayData(self, value): def qArrayData(self, value):
if self.qtVersion() >= 0x60000: if self.qtVersion() >= 0x60000:
dd, data, size = self.split('ppp', value) dd, data, length = self.split('ppp', value)
if dd: if dd:
_, _, alloc = self.split('iip', dd) _, _, alloc = self.split('iip', dd)
else: # fromRawData else: # fromRawData
alloc = size alloc = length
return data, size, alloc return data, length, alloc
return self.qArrayDataHelper(self.extractPointer(value)) return self.qArrayDataHelper(self.extractPointer(value))
def qArrayDataHelper(self, array_data_ptr): def qArrayDataHelper(self, array_data_ptr):
@@ -586,10 +586,10 @@ class DumperBase():
if self.qtVersion() >= 0x050000: if self.qtVersion() >= 0x050000:
# QTypedArray: # QTypedArray:
# - QtPrivate::RefCount ref # - QtPrivate::RefCount ref
# - int size # - int length
# - uint alloc : 31, capacityReserved : 1 # - uint alloc : 31, capacityReserved : 1
# - qptrdiff offset # - 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 alloc = alloc & 0x7ffffff
data = array_data_ptr + offset data = array_data_ptr + offset
if self.ptrSize() == 4: if self.ptrSize() == 4:
@@ -599,43 +599,42 @@ class DumperBase():
elif self.qtVersion() >= 0x040000: elif self.qtVersion() >= 0x040000:
# Data: # Data:
# - QBasicAtomicInt ref; # - QBasicAtomicInt ref;
# - int alloc, size; # - int alloc, length;
# - [padding] # - [padding]
# - char *data; # - char *data;
if self.ptrSize() == 4: 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: else:
(ref, alloc, size, pad, data) = self.split('IIIIp', array_data_ptr) (ref, alloc, length, pad, data) = self.split('IIIIp', array_data_ptr)
else: else:
# Data: # Data:
# - QShared count; # - QShared count;
# - QChar *unicode # - QChar *unicode
# - char *ascii # - char *ascii
# - uint len: 30 # - uint len: 30
(dummy, dummy, dummy, size) = self.split('IIIp', array_data_ptr) (dummy, dummy, dummy, length) = self.split('IIIp', array_data_ptr)
size = self.extractInt(array_data_ptr + 3 * self.ptrSize()) & 0x3ffffff length = self.extractInt(array_data_ptr + 3 * self.ptrSize()) & 0x3ffffff
alloc = size # pretend. alloc = length # pretend.
data = self.extractPointer(array_data_ptr + self.ptrSize()) data = self.extractPointer(array_data_ptr + self.ptrSize())
return data, size, alloc return data, length, alloc
def encodeStringHelper(self, value, limit): def encodeStringHelper(self, value, limit):
data, size, alloc = self.qArrayData(value) data, length, alloc = self.qArrayData(value)
if alloc != 0: if alloc != 0:
self.check(0 <= size and size <= alloc and alloc <= 100 * 1000 * 1000) self.check(0 <= length and length <= alloc and alloc <= 100 * 1000 * 1000)
elided, shown = self.computeLimit(2 * size, 2 * limit) shown = self.computeLimit(2 * length, 2 * limit)
return elided, self.readMemory(data, shown) return length, self.readMemory(data, shown)
def encodeByteArrayHelper(self, value, limit): def encodeByteArrayHelper(self, value, limit):
data, size, alloc = self.qArrayData(value) data, length, alloc = self.qArrayData(value)
if alloc != 0: if alloc != 0:
self.check(0 <= size and size <= alloc and alloc <= 100 * 1000 * 1000) self.check(0 <= length and length <= alloc and alloc <= 100 * 1000 * 1000)
elided, shown = self.computeLimit(size, limit) shown = self.computeLimit(length, limit)
return elided, self.readMemory(data, shown) return length, self.readMemory(data, shown)
def putCharArrayValue(self, data, size, charSize, def putCharArrayValue(self, data, length, charSize,
displayFormat=DisplayFormat.Automatic): displayFormat=DisplayFormat.Automatic):
bytelen = size * charSize shown = self.computeLimit(length, self.displayStringLimit)
elided, shown = self.computeLimit(bytelen, self.displayStringLimit)
mem = self.readMemory(data, shown) mem = self.readMemory(data, shown)
if charSize == 1: if charSize == 1:
if displayFormat in (DisplayFormat.Latin1String, DisplayFormat.SeparateLatin1String): if displayFormat in (DisplayFormat.Latin1String, DisplayFormat.SeparateLatin1String):
@@ -650,13 +649,13 @@ class DumperBase():
encodingType = 'ucs4' encodingType = 'ucs4'
#childType = 'int' #childType = 'int'
self.putValue(mem, encodingType, elided=elided) self.putValue(mem, encodingType, length=length)
if displayFormat in ( if displayFormat in (
DisplayFormat.SeparateLatin1String, DisplayFormat.SeparateLatin1String,
DisplayFormat.SeparateUtf8String, DisplayFormat.SeparateUtf8String,
DisplayFormat.Separate): DisplayFormat.Separate):
elided, shown = self.computeLimit(bytelen, 100000) shown = self.computeLimit(length, 100000)
self.putDisplay(encodingType + ':separate', self.readMemory(data, shown)) self.putDisplay(encodingType + ':separate', self.readMemory(data, shown))
def putCharArrayHelper(self, data, size, charType, def putCharArrayHelper(self, data, size, charType,
@@ -676,15 +675,15 @@ class DumperBase():
return self.hexencode(bytes(self.readRawMemory(addr, size))) return self.hexencode(bytes(self.readRawMemory(addr, size)))
def encodeByteArray(self, value, limit=0): def encodeByteArray(self, value, limit=0):
elided, data = self.encodeByteArrayHelper(value, limit) _, data = self.encodeByteArrayHelper(value, limit)
return data return data
def putByteArrayValue(self, value): def putByteArrayValue(self, value):
elided, data = self.encodeByteArrayHelper(value, self.displayStringLimit) length, data = self.encodeByteArrayHelper(value, self.displayStringLimit)
self.putValue(data, 'latin1', elided=elided) self.putValue(data, 'latin1', length=length)
def encodeString(self, value, limit=0): def encodeString(self, value, limit=0):
elided, data = self.encodeStringHelper(value, limit) _, data = self.encodeStringHelper(value, limit)
return data return data
def encodedUtf16ToUtf8(self, s): def encodedUtf16ToUtf8(self, s):
@@ -730,8 +729,8 @@ class DumperBase():
return inner return inner
def putStringValue(self, value): def putStringValue(self, value):
elided, data = self.encodeStringHelper(value, self.displayStringLimit) length, data = self.encodeStringHelper(value, self.displayStringLimit)
self.putValue(data, 'utf16', elided=elided) self.putValue(data, 'utf16', length=length)
def putPtrItem(self, name, value): def putPtrItem(self, name, value):
with SubItem(self, name): with SubItem(self, name):
@@ -900,12 +899,12 @@ class DumperBase():
if not self.isInt(thing): if not self.isInt(thing):
raise RuntimeError('Expected an integral value, got %s' % type(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(base)
self.checkIntType(tsize) self.checkIntType(typesize)
self.checkIntType(maximum) 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 = self.readRawMemory(base, 1)
blob = bytes() blob = bytes()
while maximum > 1: while maximum > 1:
@@ -916,8 +915,8 @@ class DumperBase():
maximum = int(maximum / 2) maximum = int(maximum / 2)
self.warn('REDUCING READING MAXIMUM TO %s' % maximum) self.warn('REDUCING READING MAXIMUM TO %s' % maximum)
#DumperBase.warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, tsize, maximum)) #DumperBase.warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, typesize, maximum))
for i in range(0, maximum, tsize): for i in range(0, maximum, typesize):
t = struct.unpack_from(code, blob, i)[0] t = struct.unpack_from(code, blob, i)[0]
if t == 0: if t == 0:
return 0, i, self.hexencode(blob[:i]) return 0, i, self.hexencode(blob[:i])
@@ -925,9 +924,9 @@ class DumperBase():
# Real end is unknown. # Real end is unknown.
return -1, maximum, self.hexencode(blob[:maximum]) return -1, maximum, self.hexencode(blob[:maximum])
def encodeCArray(self, p, tsize, limit): def encodeCArray(self, p, typesize, limit):
elided, shown, blob = self.readToFirstZero(p, tsize, limit) length, shown, blob = self.readToFirstZero(p, typesize, limit)
return elided, blob return length, blob
def putItemCount(self, count, maximum=1000000000): def putItemCount(self, count, maximum=1000000000):
# This needs to override the default value, so don't use 'put' directly. # 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.value = typish.name
self.currentType.priority = priority 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. # 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. # otherwise it's the true length.
if priority >= self.currentValue.priority: 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): def putSpecialValue(self, encoding, value='', children=None):
self.putValue(value, encoding) self.putValue(value, encoding)
@@ -1226,13 +1225,13 @@ class DumperBase():
return False return False
def putSimpleCharArray(self, base, size=None): def putSimpleCharArray(self, base, length=None):
if size is None: if length is None:
elided, shown, data = self.readToFirstZero(base, 1, self.displayStringLimit) length, shown, data = self.readToFirstZero(base, 1, self.displayStringLimit)
else: else:
elided, shown = self.computeLimit(int(size), self.displayStringLimit) shown = self.computeLimit(length)
data = self.readMemory(base, shown) data = self.readMemory(base, shown)
self.putValue(data, 'latin1', elided=elided) self.putValue(data, 'latin1', length=length)
def putDisplay(self, editFormat, value): def putDisplay(self, editFormat, value):
self.putField('editformat', editFormat) self.putField('editformat', editFormat)
@@ -1248,8 +1247,8 @@ class DumperBase():
if targetType.name in ('char', 'signed char', 'unsigned char', 'uint8_t', 'CHAR'): if targetType.name in ('char', 'signed char', 'unsigned char', 'uint8_t', 'CHAR'):
# Use UTF-8 as default for char *. # Use UTF-8 as default for char *.
self.putType(typeName) self.putType(typeName)
(elided, shown, data) = self.readToFirstZero(ptr, 1, limit) (length, shown, data) = self.readToFirstZero(ptr, 1, limit)
self.putValue(data, 'utf8', elided=elided) self.putValue(data, 'utf8', length=length)
if self.isExpanded(): if self.isExpanded():
self.putArrayData(ptr, shown, innerType) self.putArrayData(ptr, shown, innerType)
return True return True
@@ -1257,55 +1256,55 @@ class DumperBase():
if targetType.name in ('wchar_t', 'WCHAR'): if targetType.name in ('wchar_t', 'WCHAR'):
self.putType(typeName) self.putType(typeName)
charSize = self.lookupType('wchar_t').size() charSize = self.lookupType('wchar_t').size()
(elided, data) = self.encodeCArray(ptr, charSize, limit) (length, data) = self.encodeCArray(ptr, charSize, limit)
if charSize == 2: if charSize == 2:
self.putValue(data, 'utf16', elided=elided) self.putValue(data, 'utf16', length=length)
else: else:
self.putValue(data, 'ucs4', elided=elided) self.putValue(data, 'ucs4', length=length)
return True return True
if displayFormat == DisplayFormat.Latin1String: if displayFormat == DisplayFormat.Latin1String:
self.putType(typeName) self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit) (length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'latin1', elided=elided) self.putValue(data, 'latin1', length=length)
return True return True
if displayFormat == DisplayFormat.SeparateLatin1String: if displayFormat == DisplayFormat.SeparateLatin1String:
self.putType(typeName) self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit) (length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'latin1', elided=elided) self.putValue(data, 'latin1', length=length)
self.putDisplay('latin1:separate', data) self.putDisplay('latin1:separate', data)
return True return True
if displayFormat == DisplayFormat.Utf8String: if displayFormat == DisplayFormat.Utf8String:
self.putType(typeName) self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit) (length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'utf8', elided=elided) self.putValue(data, 'utf8', length=length)
return True return True
if displayFormat == DisplayFormat.SeparateUtf8String: if displayFormat == DisplayFormat.SeparateUtf8String:
self.putType(typeName) self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit) (length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'utf8', elided=elided) self.putValue(data, 'utf8', length=length)
self.putDisplay('utf8:separate', data) self.putDisplay('utf8:separate', data)
return True return True
if displayFormat == DisplayFormat.Local8BitString: if displayFormat == DisplayFormat.Local8BitString:
self.putType(typeName) self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 1, limit) (length, data) = self.encodeCArray(ptr, 1, limit)
self.putValue(data, 'local8bit', elided=elided) self.putValue(data, 'local8bit', length=length)
return True return True
if displayFormat == DisplayFormat.Utf16String: if displayFormat == DisplayFormat.Utf16String:
self.putType(typeName) self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 2, limit) (length, data) = self.encodeCArray(ptr, 2, limit)
self.putValue(data, 'utf16', elided=elided) self.putValue(data, 'utf16', length=length)
return True return True
if displayFormat == DisplayFormat.Ucs4String: if displayFormat == DisplayFormat.Ucs4String:
self.putType(typeName) self.putType(typeName)
(elided, data) = self.encodeCArray(ptr, 4, limit) (length, data) = self.encodeCArray(ptr, 4, limit)
self.putValue(data, 'ucs4', elided=elided) self.putValue(data, 'ucs4', length=length)
return True return True
return False return False
@@ -2577,17 +2576,17 @@ class DumperBase():
def extractQStringFromQDataStream(self, buf, offset): def extractQStringFromQDataStream(self, buf, offset):
""" Read a QString from the stream """ """ Read a QString from the stream """
size = struct.unpack_from('!I', buf, offset)[0] length = struct.unpack_from('!I', buf, offset)[0]
offset += 4 offset += 4
string = buf[offset:offset + size].decode('utf-16be') string = buf[offset:offset + length].decode('utf-16be')
return (string, offset + size) return (string, offset + length)
def extractQByteArrayFromQDataStream(self, buf, offset): def extractQByteArrayFromQDataStream(self, buf, offset):
""" Read a QByteArray from the stream """ """ Read a QByteArray from the stream """
size = struct.unpack_from('!I', buf, offset)[0] length = struct.unpack_from('!I', buf, offset)[0]
offset += 4 offset += 4
string = buf[offset:offset + size].decode('latin1') string = buf[offset:offset + length].decode('latin1')
return (string, offset + size) return (string, offset + length)
def extractIntFromQDataStream(self, buf, offset): def extractIntFromQDataStream(self, buf, offset):
""" Read an int from the stream """ """ 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): def qedit__QByteArray(d, value, data):
d.call('void', value, 'resize', str(len(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]) d.setValues(base, 'char', [ord(c) for c in data])
def qdump__QByteArray(d, value): def qdump__QByteArray(d, value):
if d.qtVersion() >= 0x60000: if d.qtVersion() >= 0x60000:
dd, data, size = value.split('ppi') dd, data, length = value.split('ppi')
if dd: if dd:
_, _, alloc = d.split('iii', dd) _, _, alloc = d.split('iii', dd)
else: # fromRawData else: # fromRawData
alloc = size alloc = length
else: 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)) d.check(alloc == 0 or (0 <= length and length <= alloc and alloc <= 100000000))
if size > 0: if length > 0:
d.putExpandable() d.putExpandable()
elided, shown = d.computeLimit(size, d.displayStringLimit) shown = d.computeLimit(length, d.displayStringLimit)
p = d.readMemory(data, shown) p = d.readMemory(data, shown)
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == DisplayFormat.Automatic or displayFormat == DisplayFormat.Latin1String: if displayFormat == DisplayFormat.Automatic or displayFormat == DisplayFormat.Latin1String:
d.putValue(p, 'latin1', elided=elided) d.putValue(p, 'latin1', length=length)
elif displayFormat == DisplayFormat.SeparateLatin1String: 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)) d.putDisplay('latin1:separate', d.encodeByteArray(value, limit=100000))
elif displayFormat == DisplayFormat.Utf8String: elif displayFormat == DisplayFormat.Utf8String:
d.putValue(p, 'utf8', elided=elided) d.putValue(p, 'utf8', length=length)
elif displayFormat == DisplayFormat.SeparateUtf8String: 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)) d.putDisplay('utf8:separate', d.encodeByteArray(value, limit=100000))
if d.isExpanded(): if d.isExpanded():
d.putArrayData(data, size, d.charType()) d.putArrayData(data, length, d.charType())
#def qdump__QArrayData(d, value): #def qdump__QArrayData(d, value):
# data, size, alloc = d.qArrayDataHelper(value.address()) # data, length, alloc = d.qArrayDataHelper(value.address())
# d.check(alloc == 0 or (0 <= size and size <= alloc and alloc <= 100000000)) # d.check(alloc == 0 or (0 <= length and length <= alloc and alloc <= 100000000))
# d.putValue(d.readMemory(data, size), 'latin1') # d.putValue(d.readMemory(data, length), 'latin1')
# d.putPlainChildren(value) # d.putPlainChildren(value)
@@ -81,10 +81,10 @@ def qdump__QBitArray(d, value):
else: else:
data, basize, _ = d.qArrayData(value['d']) data, basize, _ = d.qArrayData(value['d'])
unused = d.extractByte(data) if data else 0 unused = d.extractByte(data) if data else 0
size = basize * 8 - unused length = basize * 8 - unused
d.putItemCount(size) d.putItemCount(length)
if d.isExpanded(): if d.isExpanded():
with Children(d, size, maxNumChild=10000): with Children(d, length, maxNumChild=10000):
for i in d.childRange(): for i in d.childRange():
q = data + 1 + int(i / 8) q = data + 1 + int(i / 8)
with SubItem(d, i): with SubItem(d, i):
@@ -1621,17 +1621,17 @@ def qdumpHelper_QSet45(d, value):
ptrSize = d.ptrSize() ptrSize = d.ptrSize()
dptr = d.extractPointer(value) 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.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.check(-1 <= ref and ref < 100000)
d.putItemCount(size) d.putItemCount(length)
if d.isExpanded(): if d.isExpanded():
keyType = value.type[0] keyType = value.type[0]
isShort = d.qtVersion() < 0x050000 and keyType.name == 'int' isShort = d.qtVersion() < 0x050000 and keyType.name == 'int'
with Children(d, size, childType=keyType): with Children(d, length, childType=keyType):
node = hashDataFirstNode() node = hashDataFirstNode()
for i in d.childRange(): for i in d.childRange():
if isShort: if isShort:
@@ -1714,15 +1714,15 @@ def qdump__QStack(d, value):
def qdump__QPolygonF(d, value): def qdump__QPolygonF(d, value):
data, size = d.vectorData(value) data, length = d.vectorData(value)
d.putItemCount(size) d.putItemCount(length)
d.putPlotData(data, size, d.createType('@QPointF')) d.putPlotData(data, length, d.createType('@QPointF'))
def qdump__QPolygon(d, value): def qdump__QPolygon(d, value):
data, size = d.vectorData(value) data, length = d.vectorData(value)
d.putItemCount(size) d.putItemCount(length)
d.putPlotData(data, size, d.createType('@QPoint')) d.putPlotData(data, length, d.createType('@QPoint'))
def qdump__QGraphicsPolygonItem(d, value): def qdump__QGraphicsPolygonItem(d, value):
@@ -1741,14 +1741,14 @@ def qdump__QGraphicsPolygonItem(d, value):
offset = 328 if d.isMsvcTarget() else 320 offset = 328 if d.isMsvcTarget() else 320
else: else:
offset = 308 offset = 308
data, size = d.vectorData(dptr + offset) data, length = d.vectorData(dptr + offset)
d.putItemCount(size) d.putItemCount(length)
d.putPlotData(data, size, d.createType('@QPointF')) d.putPlotData(data, length, d.createType('@QPointF'))
def qedit__QString(d, value, data): def qedit__QString(d, value, data):
d.call('void', value, 'resize', str(len(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]) d.setValues(base, 'short', [ord(c) for c in data])
@@ -1758,14 +1758,14 @@ def qform__QString():
def qdump__QString(d, value): def qdump__QString(d, value):
d.putStringValue(value) d.putStringValue(value)
data, size, _ = d.stringData(value) data, length, _ = d.stringData(value)
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == DisplayFormat.Separate: if displayFormat == DisplayFormat.Separate:
d.putDisplay('utf16:separate', d.encodeString(value, limit=100000)) d.putDisplay('utf16:separate', d.encodeString(value, limit=100000))
if (size > 0): if (length > 0):
d.putExpandable() d.putExpandable()
if d.isExpanded(): if d.isExpanded():
d.putArrayData(data, size, d.createType('@QChar')) d.putArrayData(data, length, d.createType('@QChar'))
def qdump__QSettingsKey(d, value): def qdump__QSettingsKey(d, value):
@@ -1774,8 +1774,8 @@ def qdump__QSettingsKey(d, value):
def qdump__QStaticStringData(d, value): def qdump__QStaticStringData(d, value):
size = value.type[0] length = value.type[0]
(ref, size, alloc, pad, offset, data) = value.split('iii@p%ss' % (2 * size)) (ref, length, alloc, pad, offset, data) = value.split('iii@p%ss' % (2 * length))
d.putValue(d.hexencode(data), 'utf16') d.putValue(d.hexencode(data), 'utf16')
d.putPlainChildren(value) d.putPlainChildren(value)
@@ -1788,28 +1788,28 @@ def qdump__QTypedArrayData(d, value):
def qdump__QStringData(d, value): def qdump__QStringData(d, value):
(ref, size, alloc, pad, offset) = value.split('III@p') (ref, length, alloc, pad, offset) = value.split('III@p')
elided, shown = d.computeLimit(size, d.displayStringLimit) shown = d.computeLimit(length, d.displayStringLimit)
data = d.readMemory(value.address() + offset, shown * 2) data = d.readMemory(value.address() + offset, shown * 2)
d.putValue(data, 'utf16', elided=elided) d.putValue(data, 'utf16', length=length)
d.putPlainChildren(value) d.putPlainChildren(value)
def qdump__QAnyStringView(d, value): def qdump__QAnyStringView(d, value):
data, size = value.split('pp') data, length = value.split('pp')
bits = d.ptrSize() * 8 - 2 bits = d.ptrSize() * 8 - 2
tag = size >> bits tag = length >> bits
size = size & (2**bits - 1) length = length & (2**bits - 1)
elided, shown = d.computeLimit(size, d.displayStringLimit) shown = d.computeLimit(length, d.displayStringLimit)
if tag == 0: if tag == 0:
mem = d.readMemory(data, shown) mem = d.readMemory(data, shown)
d.putValue(mem, 'utf8', elided=elided) d.putValue(mem, 'utf8', length=length)
elif tag == 1: elif tag == 1:
mem = d.readMemory(data, shown) mem = d.readMemory(data, shown)
d.putValue(mem, 'latin1', elided=elided) d.putValue(mem, 'latin1', length=length)
elif tag == 2: elif tag == 2:
mem = d.readMemory(data, shown * 2) mem = d.readMemory(data, shown * 2)
d.putValue(mem, 'utf16', elided=elided) d.putValue(mem, 'utf16', length=length)
else: else:
d.putSpecialValue('empty') d.putSpecialValue('empty')
d.putPlainChildren(value) d.putPlainChildren(value)
@@ -1825,16 +1825,15 @@ def qdump__QStringView(d, value):
if idata == 0: if idata == 0:
d.putValue('(null)') d.putValue('(null)')
return return
size = value['m_size'] length = value['m_size'].integer()
isize = size.integer() shown = d.computeLimit(length, d.displayStringLimit)
elided, shown = d.computeLimit(isize, d.displayStringLimit)
mem = d.readMemory(idata, shown * 2) mem = d.readMemory(idata, shown * 2)
d.putValue(mem, 'utf16', elided=elided) d.putValue(mem, 'utf16', length=length)
if d.currentItemFormat() == DisplayFormat.Separate: if d.currentItemFormat() == DisplayFormat.Separate:
d.putDisplay('utf16:separate', mem) d.putDisplay('utf16:separate', mem)
d.putExpandable() d.putExpandable()
if d.isExpanded(): if d.isExpanded():
d.putArrayData(idata, isize, d.createType('char16_t')) d.putArrayData(idata, length, d.createType('char16_t'))
def qdump__QHashedString(d, value): def qdump__QHashedString(d, value):
@@ -1848,12 +1847,12 @@ def qdump__QQmlRefCount(d, value):
def qdump__QStringRef(d, value): def qdump__QStringRef(d, value):
(stringptr, pos, size) = value.split('pii') (stringptr, pos, length) = value.split('pii')
if stringptr == 0: if stringptr == 0:
d.putValue('(null)') d.putValue('(null)')
return return
data, ssize, alloc = d.stringData(d.createValue(stringptr, '@QString')) 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) d.putPlainChildren(value)
@@ -1937,7 +1936,7 @@ def qdump__QUrl(d, value):
userNameEnc = d.encodeString(userName) userNameEnc = d.encodeString(userName)
hostEnc = d.encodeString(host) hostEnc = d.encodeString(host)
elided, pathEnc = d.encodeStringHelper(path, d.displayStringLimit) length, pathEnc = d.encodeStringHelper(path, d.displayStringLimit)
url = d.encodeString(scheme) url = d.encodeString(scheme)
url += '3a002f002f00' # '://' url += '3a002f002f00' # '://'
if len(userNameEnc): if len(userNameEnc):
@@ -1946,7 +1945,7 @@ def qdump__QUrl(d, value):
if port >= 0: if port >= 0:
url += '3a00' + ''.join(['%02x00' % ord(c) for c in str(port)]) url += '3a00' + ''.join(['%02x00' % ord(c) for c in str(port)])
url += pathEnc url += pathEnc
d.putValue(url, 'utf16', elided=elided) d.putValue(url, 'utf16', length=length)
displayFormat = d.currentItemFormat() displayFormat = d.currentItemFormat()
if displayFormat == DisplayFormat.Separate: if displayFormat == DisplayFormat.Separate:
@@ -2162,7 +2161,7 @@ def qdumpHelper__QVariant6(d, value):
qdumpHelper_QVariant_0(d, value) qdumpHelper_QVariant_0(d, value)
return return
revision, alignment, size, flags, variantType, metaObjectPtr, name = \ revision, alignment, length, flags, variantType, metaObjectPtr, name = \
d.split('HHIIIpp', metaTypeInterface) d.split('HHIIIpp', metaTypeInterface)
# Well-known simple type. # Well-known simple type.
@@ -2241,7 +2240,7 @@ def qdumpHelper__QVariant45(d, value):
base1 = d.extractPointer(value) base1 = d.extractPointer(value)
#DumperBase.warn('BASE 1: %s %s' % (base1, innert)) #DumperBase.warn('BASE 1: %s %s' % (base1, innert))
base = d.extractPointer(base1) base = d.extractPointer(base1)
#DumperBase.warn('SIZE 1: %s' % size) #DumperBase.warn('SIZE 1: %s' % length)
val = d.createValue(base, innerType) val = d.createValue(base, innerType)
else: else:
#DumperBase.warn('DIRECT ITEM 1: %s' % innerType) #DumperBase.warn('DIRECT ITEM 1: %s' % innerType)
@@ -2268,7 +2267,7 @@ def qdumpHelper__QVariant45(d, value):
d.putSpecialValue('notcallable') d.putSpecialValue('notcallable')
return None return None
ptr = p.pointer() ptr = p.pointer()
(elided, blob) = d.encodeCArray(ptr, 1, 100) (_, blob) = d.encodeCArray(ptr, 1, 100)
innerType = d.hexdecode(blob) innerType = d.hexdecode(blob)
# Prefer namespaced version. # Prefer namespaced version.
@@ -2303,34 +2302,34 @@ def qform__QVector():
def qdump__QVector(d, value): def qdump__QVector(d, value):
if d.qtVersion() >= 0x060000: if d.qtVersion() >= 0x060000:
data, size = d.listData(value) data, length = d.listData(value)
d.putItemCount(size) d.putItemCount(length)
d.putPlotData(data, size, d.createType(value.type.ltarget[0])) d.putPlotData(data, length, d.createType(value.type.ltarget[0]))
# g++ 9.3 does not add the template parameter list to the debug info. # g++ 9.3 does not add the template parameter list to the debug info.
# Fake it for the common case: # Fake it for the common case:
if value.type.name == d.qtNamespace() + "QVector": if value.type.name == d.qtNamespace() + "QVector":
d.putBetterType(value.type.name + '<' + value.type.ltarget[0].name + '>') d.putBetterType(value.type.name + '<' + value.type.ltarget[0].name + '>')
else: else:
data, size = d.vectorData(value) data, length = d.vectorData(value)
d.putItemCount(size) d.putItemCount(length)
d.putPlotData(data, size, d.createType(value.type[0])) d.putPlotData(data, length, d.createType(value.type[0]))
if False: if False:
def qdump__QObjectConnectionList(d, value): def qdump__QObjectConnectionList(d, value):
data, size = d.vectorData(value) data, length = d.vectorData(value)
d.putItemCount(size) d.putItemCount(length)
d.putPlotData(data, size, d.createType('@QObjectPrivate::ConnectionList')) d.putPlotData(data, length, d.createType('@QObjectPrivate::ConnectionList'))
def qdump__QVarLengthArray(d, value): def qdump__QVarLengthArray(d, value):
if d.qtVersion() >= 0x060000: if d.qtVersion() >= 0x060000:
cap, size, data = value.split('QQp') cap, length, data = value.split('QQp')
else: else:
cap, size, data = value.split('iip') cap, length, data = value.split('iip')
d.check(0 <= size) d.check(0 <= length)
d.putItemCount(size) d.putItemCount(length)
d.putPlotData(data, size, value.type[0]) d.putPlotData(data, length, value.type[0])
def qdump__QSharedPointer(d, value): def qdump__QSharedPointer(d, value):
@@ -2401,20 +2400,20 @@ def qdump__QXmlAttributes(d, value):
def qdump__QXmlStreamStringRef(d, value): def qdump__QXmlStreamStringRef(d, value):
s = value['m_string'] s = value['m_string']
(data, size, alloc) = d.stringData(s) (data, length, alloc) = d.stringData(s)
data += 2 * int(value['m_position']) data += 2 * int(value['m_position'])
size = int(value['m_size']) length = int(value['m_size'])
s = d.readMemory(data, 2 * size) s = d.readMemory(data, 2 * length)
d.putValue(s, 'utf16') d.putValue(s, 'utf16')
d.putPlainChildren(value) d.putPlainChildren(value)
def qdump__QXmlStreamAttribute(d, value): def qdump__QXmlStreamAttribute(d, value):
s = value['m_name']['m_string'] 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']) data += 2 * int(value['m_name']['m_position'])
size = int(value['m_name']['m_size']) length = int(value['m_name']['m_size'])
s = d.readMemory(data, 2 * size) s = d.readMemory(data, 2 * length)
d.putValue(s, 'utf16') d.putValue(s, 'utf16')
d.putPlainChildren(value) d.putPlainChildren(value)
@@ -2505,8 +2504,8 @@ def qdump__QV4__ExecutionContext(d, value):
def qdump__QQmlSourceLocation(d, value): def qdump__QQmlSourceLocation(d, value):
(sourceFile, line, col) = value.split('pHH') (sourceFile, line, col) = value.split('pHH')
(data, size, alloc) = d.stringData(value) (data, length, alloc) = d.stringData(value)
d.putValue(d.readMemory(data, 2 * size), 'utf16') d.putValue(d.readMemory(data, 2 * length), 'utf16')
d.putField('valuesuffix', ':%s:%s' % (line, col)) d.putField('valuesuffix', ':%s:%s' % (line, col))
d.putPlainChildren(value) d.putPlainChildren(value)
@@ -3345,9 +3344,7 @@ def qdump__QJsonValue(d, value):
return return
if t == 3: if t == 3:
d.putType('QJsonValue (String)') d.putType('QJsonValue (String)')
string = value.split('{@QString}')[0] d.putStringValue(value.split('{@QString}')[0])
elided, base = d.encodeString(string, d.displayStringLimit)
d.putValue(base, 'utf16', elided=elided)
return return
if t == 4: if t == 4:
d.putType('QJsonValue (Array)') 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_len = d.extractInt(bytedata)
bytedata_data = bytedata + 4 # sizeof(QtCbor::ByteData) header part 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) 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): 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()) if (!value.isEmpty())
str << "value=\"" << value << doubleQuoteComma; str << "value=\"" << value << doubleQuoteComma;
if (elided) if (valuelen)
str << "valueelided=\"" << elided << doubleQuoteComma; str << "valuelen=\"" << valuelen << doubleQuoteComma;
if (!editvalue.isEmpty()) if (!editvalue.isEmpty())
str << "editvalue=\"<...>\","; str << "editvalue=\"<...>\",";
@@ -300,9 +300,9 @@ void WatchItem::parseHelper(const GdbMi &input, bool maySort)
if (mi.isValid()) if (mi.isValid())
id = mi.toInt(); id = mi.toInt();
mi = input["valueelided"]; mi = input["valuelen"];
if (mi.isValid()) if (mi.isValid())
elided = mi.toInt(); valuelen = mi.toInt();
mi = input["bitpos"]; mi = input["bitpos"];
if (mi.isValid()) 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 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 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 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 int arrayIndex = -1; // -1 if not an array member
uchar sortGroup = 0; // 0 - ordinary member, 1 - vptr, 2 - base class uchar sortGroup = 0; // 0 - ordinary member, 1 - vptr, 2 - base class
bool wantsChildren = false; 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); QString v = quoteUnprintable(item->value);
if (v.endsWith('"')) { if (v.endsWith('"')) {
if (item->elided) { if (item->valuelen > maxLength) {
v.chop(1); v.chop(1);
v.append("...\""); v.append("...\"");
} }
int len = item->elided ? item->elided : item->value.length() - 2; if (item->valuelen > 0)
v += QString(" (%1)").arg(len > 0 ? QString::number(len) : "unknown length"); v += QString(" (%1)").arg(item->valuelen);
return v; return v;
} }
@@ -1297,7 +1297,7 @@ Qt::ItemFlags WatchModel::flags(const QModelIndex &idx) const
// FIXME: Forcing types is not implemented yet. // FIXME: Forcing types is not implemented yet.
//if (idx.column() == 2) //if (idx.column() == 2)
// return editable; // Watcher types can be set by force. // 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. return editable; // Watcher values are sometimes editable.
} }
} else if (item->isLocal()) { } else if (item->isLocal()) {
@@ -1305,7 +1305,7 @@ Qt::ItemFlags WatchModel::flags(const QModelIndex &idx) const
return notEditable; return notEditable;
if (isRunning && !m_engine->hasCapability(AddWatcherWhileRunningCapability)) if (isRunning && !m_engine->hasCapability(AddWatcherWhileRunningCapability))
return notEditable; return notEditable;
if (column == ValueColumn && item->valueEditable && !item->elided) if (column == ValueColumn && item->valueEditable && item->valuelen >= 0)
return editable; // Locals values are sometimes editable. return editable; // Locals values are sometimes editable.
if (column == ValueColumn && item->arrayIndex >= 0) if (column == ValueColumn && item->arrayIndex >= 0)
return editable; return editable;