From e17c96cf11c90d2f36724265ed95655cac3e38e7 Mon Sep 17 00:00:00 2001 From: David Schulz Date: Fri, 21 Feb 2020 10:10:00 +0100 Subject: [PATCH] Dumper: move global enums and functions to utils Change-Id: I11f5f0d970cd23a5fd907d33daa3cb8a441d0c58 Reviewed-by: hjk --- share/qtcreator/debugger/cdbbridge.py | 29 +- share/qtcreator/debugger/creatortypes.py | 2 +- share/qtcreator/debugger/dumper.py | 623 ++++++++++------------- share/qtcreator/debugger/gdbbridge.py | 146 +++--- share/qtcreator/debugger/lldbbridge.py | 169 +++--- share/qtcreator/debugger/misctypes.py | 5 +- share/qtcreator/debugger/opencvtypes.py | 7 +- share/qtcreator/debugger/pdbbridge.py | 4 +- share/qtcreator/debugger/qttypes.py | 86 ++-- share/qtcreator/debugger/stdtypes.py | 37 +- share/qtcreator/debugger/utils.py | 130 +++++ 11 files changed, 636 insertions(+), 602 deletions(-) create mode 100644 share/qtcreator/debugger/utils.py diff --git a/share/qtcreator/debugger/cdbbridge.py b/share/qtcreator/debugger/cdbbridge.py index 097494cc90a..d31f13e7f17 100644 --- a/share/qtcreator/debugger/cdbbridge.py +++ b/share/qtcreator/debugger/cdbbridge.py @@ -28,6 +28,7 @@ import os import sys import cdbext import re +from utils import TypeCode sys.path.insert(1, os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))) @@ -47,19 +48,19 @@ class FakeVoidType(cdbext.Type): def code(self): if self.typeName.endswith('*'): - return TypeCodePointer + return TypeCode.TypeCodePointer if self.typeName.endswith(']'): - return TypeCodeArray - return TypeCodeVoid + return TypeCode.TypeCodeArray + return TypeCode.TypeCodeVoid def unqualified(self): return self def target(self): code = self.code() - if code == TypeCodePointer: + if code == TypeCode.TypeCodePointer: return FakeVoidType(self.typeName[:-1], self.dumper) - if code == TypeCodeVoid: + if code == TypeCode.TypeCodeVoid: return self try: return FakeVoidType(self.typeName[:self.typeName.rindex('[')], self.dumper) @@ -105,7 +106,7 @@ class Dumper(DumperBase): val.type = self.fromNativeType(nativeValue.type()) # There is no cdb api for the size of bitfields. # Workaround this issue by parsing the native debugger text for integral types. - if val.type.code == TypeCodeIntegral: + if val.type.code == TypeCode.TypeCodeIntegral: integerString = nativeValue.nativeDebuggerValue() if integerString == 'true': val.ldata = int(1).to_bytes(1, byteorder='little') @@ -128,7 +129,7 @@ class Dumper(DumperBase): except: # read raw memory in case the integerString can not be interpreted pass - if val.type.code == TypeCodeEnum: + if val.type.code == TypeCode.TypeCodeEnum: val.ldisplay = self.enumValue(nativeValue) val.isBaseClass = val.name == val.type.name val.nativeValue = nativeValue @@ -159,21 +160,21 @@ class Dumper(DumperBase): nativeType = FakeVoidType(nativeType.name(), self) code = nativeType.code() - if code == TypeCodePointer: + if code == TypeCode.TypeCodePointer: if not nativeType.name().startswith(''): targetType = self.lookupType(nativeType.targetName(), nativeType.moduleId()) if targetType is not None: return self.createPointerType(targetType) - code = TypeCodeFunction + code = TypeCode.TypeCodeFunction - if code == TypeCodeArray: + if code == TypeCode.TypeCodeArray: # cdb reports virtual function tables as arrays those ar handled separetly by # the DumperBase. Declare those types as structs prevents a lookup to a none existing type if not nativeType.name().startswith('__fptr()') and not nativeType.name().startswith(' align else align diff --git a/share/qtcreator/debugger/creatortypes.py b/share/qtcreator/debugger/creatortypes.py index cfdd248b232..52c2b4a97cf 100644 --- a/share/qtcreator/debugger/creatortypes.py +++ b/share/qtcreator/debugger/creatortypes.py @@ -234,7 +234,7 @@ def qdump__CPlusPlus__Internal__PPToken(d, value): data, size, alloc = d.byteArrayData(value["m_src"]) length = value["f"]["utf16chars"].integer() offset = value["utf16charOffset"].integer() - #warn("size: %s, alloc: %s, offset: %s, length: %s, data: %s" + #DumperBase.warn("size: %s, alloc: %s, offset: %s, length: %s, data: %s" # % (size, alloc, offset, length, data)) d.putValue(d.readMemory(data + offset, min(100, length)), "latin1") d.putPlainChildren(value) diff --git a/share/qtcreator/debugger/dumper.py b/share/qtcreator/debugger/dumper.py index 8ce967d3a55..6d363685370 100644 --- a/share/qtcreator/debugger/dumper.py +++ b/share/qtcreator/debugger/dumper.py @@ -34,15 +34,19 @@ import re import time import inspect import threading +from utils import DisplayFormat, TypeCode try: # That's only used in native combined debugging right now, so # we do not need to hard fail in cases of partial python installation # that will never use this. import json -except: +except ModuleNotFoundError: + DumperBase.warn("Python module json not found. " + "Native combined debugging might not work.") pass + if sys.version_info[0] >= 3: xrange = range toInteger = int @@ -50,98 +54,6 @@ else: toInteger = long -# Debugger start modes. Keep in sync with DebuggerStartMode in debuggerconstants.h -NoStartMode, \ -StartInternal, \ -StartExternal, \ -AttachExternal, \ -AttachCrashedExternal, \ -AttachCore, \ -AttachToRemoteServer, \ -AttachToRemoteProcess, \ -StartRemoteProcess, \ - = range(0, 9) - - -# Known special formats. Keep in sync with DisplayFormat in debuggerprotocol.h -AutomaticFormat, \ -RawFormat, \ -SimpleFormat, \ -EnhancedFormat, \ -SeparateFormat, \ -Latin1StringFormat, \ -SeparateLatin1StringFormat, \ -Utf8StringFormat, \ -SeparateUtf8StringFormat, \ -Local8BitStringFormat, \ -Utf16StringFormat, \ -Ucs4StringFormat, \ -Array10Format, \ -Array100Format, \ -Array1000Format, \ -Array10000Format, \ -ArrayPlotFormat, \ -CompactMapFormat, \ -DirectQListStorageFormat, \ -IndirectQListStorageFormat, \ - = range(0, 20) - -# Breakpoints. Keep synchronized with BreakpointType in breakpoint.h -UnknownType, \ -BreakpointByFileAndLine, \ -BreakpointByFunction, \ -BreakpointByAddress, \ -BreakpointAtThrow, \ -BreakpointAtCatch, \ -BreakpointAtMain, \ -BreakpointAtFork, \ -BreakpointAtExec, \ -BreakpointAtSysCall, \ -WatchpointAtAddress, \ -WatchpointAtExpression, \ -BreakpointOnQmlSignalEmit, \ -BreakpointAtJavaScriptThrow, \ - = range(0, 14) - - -# Internal codes for types keep in sync with cdbextensions pytype.cpp -TypeCodeTypedef, \ -TypeCodeStruct, \ -TypeCodeVoid, \ -TypeCodeIntegral, \ -TypeCodeFloat, \ -TypeCodeEnum, \ -TypeCodePointer, \ -TypeCodeArray, \ -TypeCodeComplex, \ -TypeCodeReference, \ -TypeCodeFunction, \ -TypeCodeMemberPointer, \ -TypeCodeFortranString, \ -TypeCodeUnresolvable, \ -TypeCodeBitfield, \ -TypeCodeRValueReference, \ - = range(0, 16) - -def isIntegralTypeName(name): - return name in ('int', 'unsigned int', 'signed int', - 'short', 'unsigned short', - 'long', 'unsigned long', - 'long long', 'unsigned long long', - 'char', 'signed char', 'unsigned char', - 'bool') - -def isFloatingPointTypeName(name): - return name in ('float', 'double', 'long double') - - -def arrayForms(): - return [ArrayPlotFormat] - -def mapForms(): - return [CompactMapFormat] - - class ReportItem: """ Helper structure to keep temporary 'best' information about a value @@ -159,21 +71,6 @@ class ReportItem: % (self.value, self.encoding, self.priority, self.elided) -def warn(message): - DumperBase.warn(message) - -def xwarn(message): - warn(message) - import traceback - traceback.print_stack() - -def error(message): - raise RuntimeError(message) - -def showException(msg, exType, exValue, exTraceback): - DumperBase.showException(msg, exType, exValue, exTraceback) - - class Timer: def __init__(self, d, desc): self.d = d @@ -220,7 +117,7 @@ class Children: def __exit__(self, exType, exValue, exTraceBack): if exType is not None: if self.d.passExceptions: - showException('CHILDREN', exType, exValue, exTraceBack) + self.d.showException('CHILDREN', exType, exValue, exTraceBack) self.d.putSpecialValue('notaccessible') self.d.putNumChild(0) if self.d.currentMaxNumChild is not None: @@ -267,11 +164,11 @@ class DumperBase: @staticmethod def showException(msg, exType, exValue, exTraceback): - warn('**** CAUGHT EXCEPTION: %s ****' % msg) + self.warn('**** CAUGHT EXCEPTION: %s ****' % msg) try: import traceback for line in traceback.format_exception(exType, exValue, exTraceback): - warn('%s' % line) + self.warn('%s' % line) except: pass @@ -353,9 +250,9 @@ class DumperBase: self.uninitialized = list(map(lambda x: self.hexdecode(x), self.uninitialized)) self.partialUpdate = int(args.get('partial', '0')) self.fallbackQtVersion = 0x50200 - #warn('NAMESPACE: "%s"' % self.qtNamespace()) - #warn('EXPANDED INAMES: %s' % self.expandedINames) - #warn('WATCHERS: %s' % self.watchers) + #DumperBase.warn('NAMESPACE: "%s"' % self.qtNamespace()) + #DumperBase.warn('EXPANDED INAMES: %s' % self.expandedINames) + #DumperBase.warn('WATCHERS: %s' % self.watchers) def resetPerStepCaches(self): self.perStepCache = {} @@ -363,7 +260,7 @@ class DumperBase: def resetCaches(self): # This is a cache mapping from 'type name' to 'display alternatives'. - self.qqFormats = { 'QVariant (QVariantMap)' : mapForms() } + self.qqFormats = { 'QVariant (QVariantMap)' : [DisplayFormat.CompactMapFormat] } # This is a cache of all known dumpers. self.qqDumpers = {} # Direct type match @@ -434,7 +331,7 @@ class DumperBase: self.currentType = ReportItem(); def exitSubItem(self, item, exType, exValue, exTraceBack): - #warn('CURRENT VALUE: %s: %s %s' % + #DumperBase.warn('CURRENT VALUE: %s: %s %s' % # (self.currentIName, self.currentValue, self.currentType)) if not exType is None: if self.passExceptions: @@ -493,7 +390,7 @@ class DumperBase: def stripForFormat(self, typeName): if not isinstance(typeName, str): - error('Expected string in stripForFormat(), got %s' % type(typeName)) + raise RuntimeError('Expected string in stripForFormat(), got %s' % type(typeName)) if typeName in self.cachedFormats: return self.cachedFormats[typeName] stripped = '' @@ -541,7 +438,7 @@ class DumperBase: tdata.name = typeId tdata.typeId = typeId tdata.lbitsize = 16 - tdata.code = TypeCodeIntegral + tdata.code = TypeCode.TypeCodeIntegral self.registerType(typeId, tdata) typeId = 'QChar' @@ -549,7 +446,7 @@ class DumperBase: tdata.name = typeId tdata.typeId = typeId tdata.lbitsize = 16 - tdata.code = TypeCodeStruct + tdata.code = TypeCode.TypeCodeStruct tdata.lfields = [self.Field(dumper=self, name='ucs', type='unsigned short', bitsize=16, bitpos=0)] tdata.lalignment = 2 tdata.templateArguments = [] @@ -576,14 +473,14 @@ class DumperBase: inner = inner[6:].strip() if inner.endswith(' const'): inner = inner[:-6].strip() - #warn("FOUND: %s" % inner) + #DumperBase.warn("FOUND: %s" % inner) targs.append(inner) - #warn("SPLITTING %s" % typename) + #DumperBase.warn("SPLITTING %s" % typename) level = 0 inner = '' for c in typename[::-1]: # Reversed... - #warn("C: %s" % c) + #DumperBase.warn("C: %s" % c) if c == '>': if level > 0: inner += c @@ -597,7 +494,7 @@ class DumperBase: inner = '' break elif c == ',': - #warn('c: %s level: %s' % (c, level)) + #DumperBase.warn('c: %s level: %s' % (c, level)) if level == 1: push(inner) inner = '' @@ -606,7 +503,7 @@ class DumperBase: else: inner += c - #warn("TARGS: %s %s" % (typename, targs)) + #DumperBase.warn("TARGS: %s %s" % (typename, targs)) res = [] for item in targs[::-1]: if len(item) == 0: @@ -626,7 +523,7 @@ class DumperBase: res.append(val) else: res.append(self.Type(self, item)) - #warn("RES: %s %s" % (typename, [(None if t is None else t.name) for t in res])) + #DumperBase.warn("RES: %s %s" % (typename, [(None if t is None else t.name) for t in res])) return res # Hex decoding operating on str, return str. @@ -729,12 +626,12 @@ class DumperBase: return elided, self.readMemory(data, shown) def putCharArrayValue(self, data, size, charSize, - displayFormat = AutomaticFormat): + displayFormat = DisplayFormat.AutomaticFormat): bytelen = size * charSize elided, shown = self.computeLimit(bytelen, self.displayStringLimit) mem = self.readMemory(data, shown) if charSize == 1: - if displayFormat in (Latin1StringFormat, SeparateLatin1StringFormat): + if displayFormat in (DisplayFormat.Latin1StringFormat, DisplayFormat.SeparateLatin1StringFormat): encodingType = 'latin1' else: encodingType = 'utf8' @@ -748,12 +645,12 @@ class DumperBase: self.putValue(mem, encodingType, elided=elided) - if displayFormat in (SeparateLatin1StringFormat, SeparateUtf8StringFormat, SeparateFormat): + if displayFormat in (DisplayFormat.SeparateLatin1StringFormat, DisplayFormat.SeparateUtf8StringFormat, DisplayFormat.SeparateFormat): elided, shown = self.computeLimit(bytelen, 100000) self.putDisplay(encodingType + ':separate', self.readMemory(data, shown)) def putCharArrayHelper(self, data, size, charType, - displayFormat = AutomaticFormat, + displayFormat = DisplayFormat.AutomaticFormat, makeExpandable = True): charSize = charType.size() self.putCharArrayValue(data, size, charSize, displayFormat = displayFormat) @@ -976,7 +873,7 @@ class DumperBase: def check(self, exp): if not exp: - error('Check failed: %s' % exp) + raise RuntimeError('Check failed: %s' % exp) def checkRef(self, ref): # Assume there aren't a million references to any object. @@ -985,7 +882,7 @@ class DumperBase: def checkIntType(self, thing): if not self.isInt(thing): - error('Expected an integral value, got %s' % type(thing)) + raise RuntimeError('Expected an integral value, got %s' % type(thing)) def readToFirstZero(self, base, tsize, maximum): self.checkIntType(base) @@ -1001,9 +898,9 @@ class DumperBase: break except: maximum = int(maximum / 2) - warn('REDUCING READING MAXIMUM TO %s' % maximum) + self.warn('REDUCING READING MAXIMUM TO %s' % maximum) - #warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, tsize, maximum)) + #DumperBase.warn('BASE: 0x%x TSIZE: %s MAX: %s' % (base, tsize, maximum)) for i in xrange(0, maximum, tsize): t = struct.unpack_from(code, blob, i)[0] if t == 0: @@ -1179,7 +1076,7 @@ class DumperBase: self.putItem(value) def isExpanded(self): - #warn('IS EXPANDED: %s in %s: %s' % (self.currentIName, + #DumperBase.warn('IS EXPANDED: %s in %s: %s' % (self.currentIName, # self.expandedINames, self.currentIName in self.expandedINames)) return self.currentIName in self.expandedINames @@ -1213,7 +1110,7 @@ class DumperBase: n = arrayByteSize // innerType.size() p = value.address() - if displayFormat != RawFormat and p: + if displayFormat != DisplayFormat.RawFormat and p: if innerType.name in ('char', 'wchar_t', 'unsigned char', 'signed char', 'CHAR', 'WCHAR'): self.putCharArrayHelper(p, n, innerType, self.currentItemFormat(), makeExpandable = False) @@ -1236,7 +1133,7 @@ class DumperBase: ns = self.qtNamespace() if len(ns) > 0 and typeName.startswith(ns): typeName = typeName[len(ns):] - # warn( 'stripping %s' % typeName ) + # DumperBase.warn( 'stripping %s' % typeName ) lvl = 0 pos = None stripChunks = [] @@ -1251,24 +1148,24 @@ class DumperBase: elif s == '>': lvl -= 1 if lvl < 0 : - error("Unbalanced '<' in type, @index %d" % index) + raise RuntimeError("Unbalanced '<' in type, @index %d" % index) if lvl == 0: stripChunks.append((pos, index+1)) if lvl != 0: - error("unbalanced at end of type name") + raise RuntimeError("unbalanced at end of type name") for (f, l) in reversed(stripChunks): typeName = typeName[:f] + typeName[l:] return typeName def tryPutPrettyItem(self, typeName, value): value.check() - if self.useFancy and self.currentItemFormat() != RawFormat: + if self.useFancy and self.currentItemFormat() != DisplayFormat.RawFormat: self.putType(typeName) nsStrippedType = self.stripNamespaceFromType(typeName)\ .replace('::', '__') - #warn('STRIPPED: %s' % nsStrippedType) + #DumperBase.warn('STRIPPED: %s' % nsStrippedType) # The following block is only needed for D. if nsStrippedType.startswith('_A'): # DMD v2.058 encodes string[] as _Array_uns long long. @@ -1281,7 +1178,7 @@ class DumperBase: return True dumper = self.qqDumpers.get(nsStrippedType) - #warn('DUMPER: %s' % dumper) + #DumperBase.warn('DUMPER: %s' % dumper) if dumper is not None: dumper(self, value) return True @@ -1308,7 +1205,7 @@ class DumperBase: # This is shared by pointer and array formatting. def tryPutSimpleFormattedPointer(self, ptr, typeName, innerType, displayFormat, limit): - if displayFormat == AutomaticFormat: + if displayFormat == DisplayFormat.AutomaticFormat: if innerType.name in ('char', 'signed char', 'unsigned char', 'CHAR'): # Use UTF-8 as default for char *. self.putType(typeName) @@ -1328,45 +1225,45 @@ class DumperBase: self.putValue(data, 'ucs4', elided=elided) return True - if displayFormat == Latin1StringFormat: + if displayFormat == DisplayFormat.Latin1StringFormat: self.putType(typeName) (elided, data) = self.encodeCArray(ptr, 1, limit) self.putValue(data, 'latin1', elided=elided) return True - if displayFormat == SeparateLatin1StringFormat: + if displayFormat == DisplayFormat.SeparateLatin1StringFormat: self.putType(typeName) (elided, data) = self.encodeCArray(ptr, 1, limit) self.putValue(data, 'latin1', elided=elided) self.putDisplay('latin1:separate', data) return True - if displayFormat == Utf8StringFormat: + if displayFormat == DisplayFormat.Utf8StringFormat: self.putType(typeName) (elided, data) = self.encodeCArray(ptr, 1, limit) self.putValue(data, 'utf8', elided=elided) return True - if displayFormat == SeparateUtf8StringFormat: + if displayFormat == DisplayFormat.SeparateUtf8StringFormat: self.putType(typeName) (elided, data) = self.encodeCArray(ptr, 1, limit) self.putValue(data, 'utf8', elided=elided) self.putDisplay('utf8:separate', data) return True - if displayFormat == Local8BitStringFormat: + if displayFormat == DisplayFormat.Local8BitStringFormat: self.putType(typeName) (elided, data) = self.encodeCArray(ptr, 1, limit) self.putValue(data, 'local8bit', elided=elided) return True - if displayFormat == Utf16StringFormat: + if displayFormat == DisplayFormat.Utf16StringFormat: self.putType(typeName) (elided, data) = self.encodeCArray(ptr, 2, limit) self.putValue(data, 'utf16', elided=elided) return True - if displayFormat == Ucs4StringFormat: + if displayFormat == DisplayFormat.Ucs4StringFormat: self.putType(typeName) (elided, data) = self.encodeCArray(ptr, 4, limit) self.putValue(data, 'ucs4', elided=elided) @@ -1390,12 +1287,12 @@ class DumperBase: def putFormattedPointerX(self, value): self.putOriginalAddress(value.address()) - #warn("PUT FORMATTED: %s" % value) + #DumperBase.warn("PUT FORMATTED: %s" % value) pointer = value.pointer() self.putAddress(pointer) - #warn('POINTER: 0x%x' % pointer) + #DumperBase.warn('POINTER: 0x%x' % pointer) if pointer == 0: - #warn('NULL POINTER') + #DumperBase.warn('NULL POINTER') self.putType(value.type) self.putValue('0x0') self.putNumChild(0) @@ -1408,7 +1305,7 @@ class DumperBase: except: # Failure to dereference a pointer should at least # show the value of a pointer. - #warn('BAD POINTER: %s' % value) + #DumperBase.warn('BAD POINTER: %s' % value) self.putValue('0x%x' % pointer) self.putType(typeName) self.putNumChild(0) @@ -1422,15 +1319,15 @@ class DumperBase: innerType = value.type.target() #.unqualified() if innerType.name == 'void': - #warn('VOID POINTER: %s' % displayFormat) + #DumperBase.warn('VOID POINTER: %s' % displayFormat) self.putType(typeName) self.putSymbolValue(pointer) self.putNumChild(0) return - if displayFormat == RawFormat: + if displayFormat == DisplayFormat.RawFormat: # Explicitly requested bald pointer. - #warn('RAW') + #DumperBase.warn('RAW') self.putType(typeName) self.putValue('0x%x' % pointer) self.putNumChild(1) @@ -1441,38 +1338,38 @@ class DumperBase: return limit = self.displayStringLimit - if displayFormat in (SeparateLatin1StringFormat, SeparateUtf8StringFormat): + if displayFormat in (DisplayFormat.SeparateLatin1StringFormat, DisplayFormat.SeparateUtf8StringFormat): limit = 1000000 if self.tryPutSimpleFormattedPointer(pointer, typeName, innerType, displayFormat, limit): self.putNumChild(1) return - if Array10Format <= displayFormat and displayFormat <= Array1000Format: - n = (10, 100, 1000, 10000)[displayFormat - Array10Format] + if DisplayFormat.Array10Format <= displayFormat and displayFormat <= DisplayFormat.Array1000Format: + n = (10, 100, 1000, 10000)[displayFormat - DisplayFormat.Array10Format] self.putType(typeName) self.putItemCount(n) self.putArrayData(value.pointer(), n, innerType) return - if innerType.code == TypeCodeFunction: + if innerType.code == TypeCode.TypeCodeFunction: # A function pointer. self.putSymbolValue(pointer) self.putType(typeName) self.putNumChild(0) return - #warn('AUTODEREF: %s' % self.autoDerefPointers) - #warn('INAME: %s' % self.currentIName) - #warn('INNER: %s' % innerType.name) + #DumperBase.warn('AUTODEREF: %s' % self.autoDerefPointers) + #DumperBase.warn('INAME: %s' % self.currentIName) + #DumperBase.warn('INNER: %s' % innerType.name) if self.autoDerefPointers: # Generic pointer type with AutomaticFormat, but never dereference char types: if innerType.name not in ('char', 'signed char', 'unsigned char', 'wchar_t', 'CHAR', 'WCHAR'): self.putDerefedPointer(value) return - #warn('GENERIC PLAIN POINTER: %s' % value.type) - #warn('ADDR PLAIN POINTER: 0x%x' % value.laddress) + #DumperBase.warn('GENERIC PLAIN POINTER: %s' % value.type) + #DumperBase.warn('ADDR PLAIN POINTER: 0x%x' % value.laddress) self.putType(typeName) self.putSymbolValue(pointer) self.putNumChild(1) @@ -1631,14 +1528,14 @@ class DumperBase: # metaObjectFunc = self.extractPointer(vtablePtr) # cmd = '((void*(*)(void*))0x%x)((void*)0x%x)' % (metaObjectFunc, objectPtr) # try: -# #warn('MO CMD: %s' % cmd) +# #DumperBase.warn('MO CMD: %s' % cmd) # res = self.parseAndEvaluate(cmd) -# #warn('MO RES: %s' % res) +# #DumperBase.warn('MO RES: %s' % res) # self.bump('successfulMetaObjectCall') # return res.pointer() # except: # self.bump('failedMetaObjectCall') -# #warn('COULD NOT EXECUTE: %s' % cmd) +# #DumperBase.warn('COULD NOT EXECUTE: %s' % cmd) # return 0 def extractMetaObjectPtr(self, objectPtr, typeobj): @@ -1659,14 +1556,14 @@ class DumperBase: metaObjectFunc = self.extractPointer(vtablePtr) cmd = '((void*(*)(void*))0x%x)((void*)0x%x)' % (metaObjectFunc, objectPtr) try: - #warn('MO CMD: %s' % cmd) + #DumperBase.warn('MO CMD: %s' % cmd) res = self.parseAndEvaluate(cmd) - #warn('MO RES: %s' % res) + #DumperBase.warn('MO RES: %s' % res) self.bump('successfulMetaObjectCall') return res.pointer() except: self.bump('failedMetaObjectCall') - #warn('COULD NOT EXECUTE: %s' % cmd) + #DumperBase.warn('COULD NOT EXECUTE: %s' % cmd) return 0 def extractStaticMetaObjectFromTypeHelper(someTypeObj): @@ -1729,12 +1626,12 @@ class DumperBase: result = self.knownStaticMetaObjects.get(typeName, None) if result is not None: # Is 0 or the static metaobject. self.bump('typecached') - #warn('CACHED RESULT: %s %s 0x%x' % (self.currentIName, typeName, result)) + #DumperBase.warn('CACHED RESULT: %s %s 0x%x' % (self.currentIName, typeName, result)) return result if not self.couldBeQObjectPointer(objectPtr): self.bump('cannotBeQObject') - #warn('DOES NOT LOOK LIKE A QOBJECT: %s' % self.currentIName) + #DumperBase.warn('DOES NOT LOOK LIKE A QOBJECT: %s' % self.currentIName) return 0 metaObjectPtr = 0 @@ -1761,7 +1658,7 @@ class DumperBase: val = self.Value(self) val.laddress = value return val.split(pattern) - error('CANNOT EXTRACT STRUCT FROM %s' % type(value)) + raise RuntimeError('CANNOT EXTRACT STRUCT FROM %s' % type(value)) def extractCString(self, addr): result = bytearray() @@ -1878,9 +1775,9 @@ class DumperBase: isQMetaObject = origType == 'QMetaObject' isQObject = origType == 'QObject' - #warn('OBJECT GUTS: %s 0x%x ' % (self.currentIName, metaObjectPtr)) + #DumperBase.warn('OBJECT GUTS: %s 0x%x ' % (self.currentIName, metaObjectPtr)) dataPtr = extractDataPtr(metaObjectPtr) - #warn('DATA PTRS: %s 0x%x ' % (self.currentIName, dataPtr)) + #DumperBase.warn('DATA PTRS: %s 0x%x ' % (self.currentIName, dataPtr)) (revision, classname, classinfo, classinfo2, methodCount, methods, @@ -2048,18 +1945,18 @@ class DumperBase: # LLDB doesn't like calling it on a derived class, possibly # due to type information living in a different shared object. #base = self.createValue(qobjectPtr, '@QObject') - #warn("CALL FUNC: 0x%x" % self.qtPropertyFunc) + #DumperBase.warn("CALL FUNC: 0x%x" % self.qtPropertyFunc) cmd = '((QVariant(*)(void*,char*))0x%x)((void*)0x%x,"%s")' \ % (self.qtPropertyFunc, qobjectPtr, name) try: - #warn('PROP CMD: %s' % cmd) + #DumperBase.warn('PROP CMD: %s' % cmd) res = self.parseAndEvaluate(cmd) - #warn('PROP RES: %s' % res) + #DumperBase.warn('PROP RES: %s' % res) except: self.bump('failedMetaObjectCall') putt(name, ' ') continue - #warn('COULD NOT EXECUTE: %s' % cmd) + #DumperBase.warn('COULD NOT EXECUTE: %s' % cmd) #self.putCallItem(name, '@QVariant', base, 'property', '"' + name + '"') if res is None: self.bump('failedMetaObjectCall2') @@ -2205,19 +2102,19 @@ class DumperBase: break def currentItemFormat(self, typeName = None): - displayFormat = self.formats.get(self.currentIName, AutomaticFormat) - if displayFormat == AutomaticFormat: + displayFormat = self.formats.get(self.currentIName, DisplayFormat.AutomaticFormat) + if displayFormat == DisplayFormat.AutomaticFormat: if typeName is None: typeName = self.currentType.value needle = None if typeName is None else self.stripForFormat(typeName) - displayFormat = self.typeformats.get(needle, AutomaticFormat) + displayFormat = self.typeformats.get(needle, DisplayFormat.AutomaticFormat) return displayFormat def putSubItem(self, component, value): # -> ReportItem if not isinstance(value, self.Value): - error('WRONG VALUE TYPE IN putSubItem: %s' % type(value)) + raise RuntimeError('WRONG VALUE TYPE IN putSubItem: %s' % type(value)) if not isinstance(value.type, self.Type): - error('WRONG TYPE TYPE IN putSubItem: %s' % type(value.type)) + raise RuntimeError('WRONG TYPE TYPE IN putSubItem: %s' % type(value.type)) res = None with SubItem(self, component): self.putItem(value) @@ -2230,7 +2127,7 @@ class DumperBase: addrBase = base innerSize = innerType.size() self.putNumChild(n) - #warn('ADDRESS: 0x%x INNERSIZE: %s INNERTYPE: %s' % (addrBase, innerSize, innerType)) + #DumperBase.warn('ADDRESS: 0x%x INNERSIZE: %s INNERTYPE: %s' % (addrBase, innerSize, innerType)) enc = innerType.simpleEncoding() if enc: self.put('childtype="%s",' % innerType.name) @@ -2262,7 +2159,7 @@ class DumperBase: if n > maxNumChild: self.putField('plotelided', n) # FIXME: Act on that in frontend n = maxNumChild - if self.currentItemFormat() == ArrayPlotFormat and innerType.isSimpleType(): + if self.currentItemFormat() == DisplayFormat.ArrayPlotFormat and innerType.isSimpleType(): enc = innerType.simpleEncoding() if enc: self.putField('editencoding', enc) @@ -2302,7 +2199,7 @@ class DumperBase: def extractPointer(self, value): try: - if value.type.code == TypeCodeArray: + if value.type.code == TypeCode.TypeCodeArray: return value.address() except: pass @@ -2337,7 +2234,7 @@ class DumperBase: return val.extractSomething(pattern, bitsize) if isinstance(value, self.Value): return value.extractSomething(pattern, bitsize) - error('CANT EXTRACT FROM %s' % type(value)) + raise RuntimeError('CANT EXTRACT FROM %s' % type(value)) # Parses a..b and a.(s).b def parseRange(self, exp): @@ -2394,13 +2291,13 @@ class DumperBase: self.putField('numchild', numchild) def handleLocals(self, variables): - #warn('VARIABLES: %s' % variables) + #DumperBase.warn('VARIABLES: %s' % variables) #with self.timer('locals'): shadowed = {} for value in variables: if value.name == 'argv': - if value.type.code == TypeCodePointer: - if value.type.ltarget.code == TypeCodePointer: + if value.type.code == TypeCode.TypeCodePointer: + if value.type.ltarget.code == TypeCode.TypeCodePointer: if value.type.ltarget.ltarget.name == 'char': self.putSpecialArgv(value) continue @@ -2430,7 +2327,7 @@ class DumperBase: def handleWatch(self, origexp, exp, iname): exp = str(exp).strip() escapedExp = self.hexencode(exp) - #warn('HANDLING WATCH %s -> %s, INAME: "%s"' % (origexp, exp, iname)) + #DumperBase.warn('HANDLING WATCH %s -> %s, INAME: "%s"' % (origexp, exp, iname)) # Grouped items separated by semicolon. if exp.find(';') >= 0: @@ -2450,7 +2347,7 @@ class DumperBase: # Special array index: e.g a[1..199] or a[1.(3).199] for stride 3. isRange, begin, step, end, template = self.parseRange(exp) if isRange: - #warn('RANGE: %s %s %s in %s' % (begin, step, end, template)) + #DumperBase.warn('RANGE: %s %s %s in %s' % (begin, step, end, template)) r = range(begin, end, step) n = len(r) with TopLevelItem(self, iname): @@ -2632,7 +2529,7 @@ class DumperBase: resdict = json.loads(payload) continue except: - warn('Cannot parse native payload: %s' % payload) + self.warn('Cannot parse native payload: %s' % payload) else: print('interpreteralien=%s' % {'service': service, 'payload': self.hexencode(payload)}) @@ -2640,7 +2537,7 @@ class DumperBase: expr = 'qt_qmlDebugClearBuffer()' res = self.parseAndEvaluate(expr) except RuntimeError as error: - warn('Cleaning buffer failed: %s: %s' % (expr, error)) + self.warn('Cleaning buffer failed: %s: %s' % (expr, error)) return resdict @@ -2651,14 +2548,14 @@ class DumperBase: try: res = self.parseAndEvaluate(expr) except RuntimeError as error: - warn('Interpreter command failed: %s: %s' % (encoded, error)) + self.warn('Interpreter command failed: %s: %s' % (encoded, error)) return {} except AttributeError as error: # Happens with LLDB and 'None' current thread. - warn('Interpreter command failed: %s: %s' % (encoded, error)) + self.warn('Interpreter command failed: %s: %s' % (encoded, error)) return {} if not res: - warn('Interpreter command failed: %s ' % encoded) + self.warn('Interpreter command failed: %s ' % encoded) return {} return self.fetchInterpreterResult() @@ -2683,7 +2580,7 @@ class DumperBase: self.doContinue() def doInsertInterpreterBreakpoint(self, args, wasPending): - #warn('DO INSERT INTERPRETER BREAKPOINT, WAS PENDING: %s' % wasPending) + #DumperBase.warn('DO INSERT INTERPRETER BREAKPOINT, WAS PENDING: %s' % wasPending) # Will fail if the service is not yet up and running. response = self.sendInterpreterRequest('setbreakpoint', args) bp = None if response is None else response.get('breakpoint', None) @@ -2738,7 +2635,7 @@ class DumperBase: self.putItemX(value) def putItemX(self, value): - #warn('PUT ITEM: %s' % value.stringify()) + #DumperBase.warn('PUT ITEM: %s' % value.stringify()) typeobj = value.type #unqualified() typeName = typeobj.name @@ -2753,23 +2650,23 @@ class DumperBase: return if not isinstance(value, self.Value): - error('WRONG TYPE IN putItem: %s' % type(self.Value)) + raise RuntimeError('WRONG TYPE IN putItem: %s' % type(self.Value)) # Try on possibly typedefed type first. if self.tryPutPrettyItem(typeName, value): - if typeobj.code == TypeCodePointer: + if typeobj.code == TypeCode.TypeCodePointer: self.putOriginalAddress(value.address()) else: self.putAddress(value.address()) return - if typeobj.code == TypeCodeTypedef: - #warn('TYPEDEF VALUE: %s' % value.stringify()) + if typeobj.code == TypeCode.TypeCodeTypedef: + #DumperBase.warn('TYPEDEF VALUE: %s' % value.stringify()) self.putItem(value.detypedef()) self.putBetterType(typeName) return - if typeobj.code == TypeCodePointer: + if typeobj.code == TypeCode.TypeCodePointer: self.putFormattedPointer(value) if value.summary and self.useFancy: self.putValue(self.hexencode(value.summary), 'utf8:1:0') @@ -2777,50 +2674,50 @@ class DumperBase: self.putAddress(value.address()) - if typeobj.code == TypeCodeFunction: - #warn('FUNCTION VALUE: %s' % value) + if typeobj.code == TypeCode.TypeCodeFunction: + #DumperBase.warn('FUNCTION VALUE: %s' % value) self.putType(typeobj) self.putSymbolValue(value.pointer()) self.putNumChild(0) return - if typeobj.code == TypeCodeEnum: - #warn('ENUM VALUE: %s' % value.stringify()) + if typeobj.code == TypeCode.TypeCodeEnum: + #DumperBase.warn('ENUM VALUE: %s' % value.stringify()) self.putType(typeobj.name) self.putValue(value.display()) self.putNumChild(0) return - if typeobj.code == TypeCodeArray: - #warn('ARRAY VALUE: %s' % value) + if typeobj.code == TypeCode.TypeCodeArray: + #DumperBase.warn('ARRAY VALUE: %s' % value) self.putCStyleArray(value) return - if typeobj.code == TypeCodeBitfield: - #warn('BITFIELD VALUE: %s %d %s' % (value.name, value.lvalue, typeName)) + if typeobj.code == TypeCode.TypeCodeBitfield: + #DumperBase.warn('BITFIELD VALUE: %s %d %s' % (value.name, value.lvalue, typeName)) self.putNumChild(0) dd = typeobj.ltarget.typeData().enumDisplay self.putValue(str(value.lvalue) if dd is None else dd(value.lvalue, value.laddress, '%d')) self.putType(typeName) return - if typeobj.code == TypeCodeIntegral: - #warn('INTEGER: %s %s' % (value.name, value)) + if typeobj.code == TypeCode.TypeCodeIntegral: + #DumperBase.warn('INTEGER: %s %s' % (value.name, value)) val = value.value() self.putNumChild(0) self.putValue(val) self.putType(typeName) return - if typeobj.code == TypeCodeFloat: - #warn('FLOAT VALUE: %s' % value) + if typeobj.code == TypeCode.TypeCodeFloat: + #DumperBase.warn('FLOAT VALUE: %s' % value) self.putValue(value.value()) self.putNumChild(0) self.putType(typeobj.name) return - if typeobj.code in (TypeCodeReference, TypeCodeRValueReference): - #warn('REFERENCE VALUE: %s' % value) + if typeobj.code in (TypeCode.TypeCodeReference, TypeCode.TypeCodeRValueReference): + #DumperBase.warn('REFERENCE VALUE: %s' % value) val = value.dereference() if val.laddress != 0: self.putItem(val) @@ -2829,13 +2726,13 @@ class DumperBase: self.putBetterType(typeName) return - if typeobj.code == TypeCodeComplex: + if typeobj.code == TypeCode.TypeCodeComplex: self.putType(typeobj) self.putValue(value.display()) self.putNumChild(0) return - if typeobj.code == TypeCodeFortranString: + if typeobj.code == TypeCode.TypeCodeFortranString: self.putValue(self.hexencode(value.data()), 'latin1') self.putNumChild(0) self.putType(typeobj) @@ -2850,12 +2747,12 @@ class DumperBase: self.putArrayData(base.pointer(), n, base.type.target()) return - #warn('SOME VALUE: %s' % value) - #warn('HAS CHILDREN VALUE: %s' % value.hasChildren()) - #warn('GENERIC STRUCT: %s' % typeobj) - #warn('INAME: %s ' % self.currentIName) - #warn('INAMES: %s ' % self.expandedINames) - #warn('EXPANDED: %s ' % (self.currentIName in self.expandedINames)) + #DumperBase.warn('SOME VALUE: %s' % value) + #DumperBase.warn('HAS CHILDREN VALUE: %s' % value.hasChildren()) + #DumperBase.warn('GENERIC STRUCT: %s' % typeobj) + #DumperBase.warn('INAME: %s ' % self.currentIName) + #DumperBase.warn('INAMES: %s ' % self.expandedINames) + #DumperBase.warn('EXPANDED: %s ' % (self.currentIName in self.expandedINames)) self.putType(typeName) if value.summary is not None and self.useFancy: @@ -2865,7 +2762,7 @@ class DumperBase: self.putNumChild(1) self.putEmptyValue() - #warn('STRUCT GUTS: %s ADDRESS: 0x%x ' % (value.name, value.address())) + #DumperBase.warn('STRUCT GUTS: %s ADDRESS: 0x%x ' % (value.name, value.address())) if self.showQObjectNames: #with self.timer(self.currentIName): self.putQObjectNameValue(value) @@ -2888,7 +2785,7 @@ class DumperBase: if addr: # Only available with Qt 5.3+ (hookVersion, x, x, x, x, x, tiVersion) = self.split('ppppppp', addr) - #warn('HOOK: %s TI: %s' % (hookVersion, tiVersion)) + #DumperBase.warn('HOOK: %s TI: %s' % (hookVersion, tiVersion)) if hookVersion >= 3: self.qtTypeInfoVersion = lambda: tiVersion return tiVersion @@ -2948,12 +2845,12 @@ class DumperBase: def check(self): if self.laddress is not None and not self.dumper.isInt(self.laddress): - error('INCONSISTENT ADDRESS: %s' % type(self.laddress)) + raise RuntimeError('INCONSISTENT ADDRESS: %s' % type(self.laddress)) if self.type is not None and not isinstance(self.type, self.dumper.Type): - error('INCONSISTENT TYPE: %s' % type(self.type)) + raise RuntimeError('INCONSISTENT TYPE: %s' % type(self.type)) def __str__(self): - #error('Not implemented') + #raise RuntimeError('Not implemented') return self.stringify() def __int__(self): @@ -2987,14 +2884,14 @@ class DumperBase: return '' def pointer(self): - if self.type.code == TypeCodeTypedef: + if self.type.code == TypeCode.TypeCodeTypedef: return self.detypedef().pointer() return self.extractInteger(self.dumper.ptrSize() * 8, True) def integer(self, bitsize=None): - if self.type.code == TypeCodeTypedef: + if self.type.code == TypeCode.TypeCodeTypedef: return self.detypedef().integer() - elif self.type.code == TypeCodeBitfield: + elif self.type.code == TypeCode.TypeCodeBitfield: return self.lvalue # Could be something like 'short unsigned int' unsigned = self.type.name == 'unsigned' \ @@ -3007,7 +2904,7 @@ class DumperBase: def floatingPoint(self): if self.nativeValue is not None and not self.dumper.isCdb: return str(self.nativeValue) - if self.type.code == TypeCodeTypedef: + if self.type.code == TypeCode.TypeCodeTypedef: return self.detypedef().floatingPoint() if self.type.size() == 8: return self.extractSomething('d', 64) @@ -3022,7 +2919,7 @@ class DumperBase: exp = (h & 0x7fff) fraction = l bit63 = (l >> 63) & 1 - #warn("SIGN: %s EXP: %s H: 0x%x L: 0x%x" % (sign, exp, h, l)) + #DumperBase.warn("SIGN: %s EXP: %s H: 0x%x L: 0x%x" % (sign, exp, h, l)) if exp == 0: if bit63 == 0: if l == 0: @@ -3039,7 +2936,7 @@ class DumperBase: sign = h >> 63 exp = (h >> 48) & 0x7fff fraction = h & (2**48 - 1) - #warn("SIGN: %s EXP: %s FRAC: %s H: 0x%x L: 0x%x" % (sign, exp, fraction, h, l)) + #DumperBase.warn("SIGN: %s EXP: %s FRAC: %s H: 0x%x L: 0x%x" % (sign, exp, fraction, h, l)) if exp == 0: if fraction == 0: res = -0.0 if sign else 0.0 @@ -3053,17 +2950,17 @@ class DumperBase: def value(self): if self.type is not None: - if self.type.code == TypeCodeEnum: + if self.type.code == TypeCode.TypeCodeEnum: return self.displayEnum() - if self.type.code == TypeCodeTypedef: + if self.type.code == TypeCode.TypeCodeTypedef: return self.detypedef().value() - if self.type.code == TypeCodeIntegral: + if self.type.code == TypeCode.TypeCodeIntegral: return self.integer() - if self.type.code == TypeCodeBitfield: + if self.type.code == TypeCode.TypeCodeBitfield: return self.integer() - if self.type.code == TypeCodeFloat: + if self.type.code == TypeCode.TypeCodeFloat: return self.floatingPoint() - if self.type.code == TypeCodePointer: + if self.type.code == TypeCode.TypeCodePointer: return self.pointer() return None @@ -3072,42 +2969,42 @@ class DumperBase: def findMemberByName(self, name): self.check() - if self.type.code == TypeCodeTypedef: + if self.type.code == TypeCode.TypeCodeTypedef: return self.findMemberByName(self.detypedef()) - if self.type.code in (TypeCodePointer, TypeCodeReference, TypeCodeRValueReference): + if self.type.code in (TypeCode.TypeCodePointer, TypeCode.TypeCodeReference, TypeCode.TypeCodeRValueReference): res = self.dereference().findMemberByName(name) if res is not None: return res - if self.type.code == TypeCodeStruct: - #warn('SEARCHING FOR MEMBER: %s IN %s' % (name, self.type.name)) + if self.type.code == TypeCode.TypeCodeStruct: + #DumperBase.warn('SEARCHING FOR MEMBER: %s IN %s' % (name, self.type.name)) members = self.members(True) - #warn('MEMBERS: %s' % members) + #DumperBase.warn('MEMBERS: %s' % members) for member in members: - #warn('CHECKING FIELD %s' % member.name) - if member.type.code == TypeCodeTypedef: + #DumperBase.warn('CHECKING FIELD %s' % member.name) + if member.type.code == TypeCode.TypeCodeTypedef: member = member.detypedef() if member.name == name: return member for member in members: - if member.type.code == TypeCodeTypedef: + if member.type.code == TypeCode.TypeCodeTypedef: member = member.detypedef() if member.name == name: # Could be base class. return member - if member.type.code == TypeCodeStruct: + if member.type.code == TypeCode.TypeCodeStruct: res = member.findMemberByName(name) if res is not None: return res return None def __getitem__(self, index): - #warn('GET ITEM %s %s' % (self, index)) + #DumperBase.warn('GET ITEM %s %s' % (self, index)) self.check() - if self.type.code == TypeCodeTypedef: - #warn('GET ITEM STRIP TYPEDEFS TO %s' % self.type.ltarget) + if self.type.code == TypeCode.TypeCodeTypedef: + #DumperBase.warn('GET ITEM STRIP TYPEDEFS TO %s' % self.type.ltarget) return self.cast(self.type.ltarget).__getitem__(index) if isinstance(index, str): - if self.type.code == TypeCodePointer: - #warn('GET ITEM %s DEREFERENCE TO %s' % (self, self.dereference())) + if self.type.code == TypeCode.TypeCodePointer: + #DumperBase.warn('GET ITEM %s DEREFERENCE TO %s' % (self, self.dereference())) return self.dereference().__getitem__(index) res = self.findMemberByName(index) if res is None: @@ -3117,40 +3014,40 @@ class DumperBase: elif isinstance(index, self.dumper.Field): field = index elif self.dumper.isInt(index): - if self.type.code == TypeCodeArray: + if self.type.code == TypeCode.TypeCodeArray: addr = self.laddress + int(index) * self.type.ltarget.size() return self.dumper.createValue(addr, self.type.ltarget) - if self.type.code == TypeCodePointer: + if self.type.code == TypeCode.TypeCodePointer: addr = self.pointer() + int(index) * self.type.ltarget.size() return self.dumper.createValue(addr, self.type.ltarget) return self.members(False)[index] else: - error('BAD INDEX TYPE %s' % type(index)) + raise RuntimeError('BAD INDEX TYPE %s' % type(index)) field.check() - #warn('EXTRACT FIELD: %s, BASE 0x%x' % (field, self.address())) - if self.type.code == TypeCodePointer: - #warn('IS TYPEDEFED POINTER!') + #DumperBase.warn('EXTRACT FIELD: %s, BASE 0x%x' % (field, self.address())) + if self.type.code == TypeCode.TypeCodePointer: + #DumperBase.warn('IS TYPEDEFED POINTER!') res = self.dereference() - #warn('WAS POINTER: %s' % res) + #DumperBase.warn('WAS POINTER: %s' % res) return field.extract(self) def extractField(self, field): if not isinstance(field, self.dumper.Field): - error('BAD INDEX TYPE %s' % type(field)) + raise RuntimeError('BAD INDEX TYPE %s' % type(field)) if field.extractor is not None: val = field.extractor(self) if val is not None: - #warn('EXTRACTOR SUCCEEDED: %s ' % val) + #DumperBase.warn('EXTRACTOR SUCCEEDED: %s ' % val) return val - if self.type.code == TypeCodeTypedef: + if self.type.code == TypeCode.TypeCodeTypedef: return self.cast(self.type.ltarget).extractField(field) - if self.type.code in (TypeCodeReference, TypeCodeRValueReference): + if self.type.code in (TypeCode.TypeCodeReference, TypeCode.TypeCodeRValueReference): return self.dereference().extractField(field) - #warn('FIELD: %s ' % field) + #DumperBase.warn('FIELD: %s ' % field) val = self.dumper.Value(self.dumper) val.name = field.name val.isBaseClass = field.isBase @@ -3169,7 +3066,7 @@ class DumperBase: fieldOffset = fieldBitpos // 8 fieldType = field.fieldType() - if fieldType.code == TypeCodeBitfield: + if fieldType.code == TypeCode.TypeCodeBitfield: fieldBitpos -= fieldOffset * 8 ldata = self.data() data = 0 @@ -3193,12 +3090,12 @@ class DumperBase: else: self.dumper.check(False) - if fieldType.code in (TypeCodeReference, TypeCodeRValueReference): + if fieldType.code in (TypeCode.TypeCodeReference, TypeCode.TypeCodeRValueReference): if val.laddress is not None: val = self.dumper.createReferenceValue(val.laddress, fieldType.ltarget) val.name = field.name - #warn('GOT VAL %s FOR FIELD %s' % (val, field)) + #DumperBase.warn('GOT VAL %s FOR FIELD %s' % (val, field)) val.lbitsize = fieldBitsize val.check() return val @@ -3207,8 +3104,8 @@ class DumperBase: # The native backends replace it in their fromNativeValue() # implementations. def members(self, includeBases): - #warn("LISTING MEMBERS OF %s" % self) - if self.type.code == TypeCodeTypedef: + #DumperBase.warn("LISTING MEMBERS OF %s" % self) + if self.type.code == TypeCode.TypeCodeTypedef: return self.detypedef().members(includeBases) tdata = self.type.typeData() @@ -3222,47 +3119,47 @@ class DumperBase: else: fields = list(tdata.lfields(self)) - #warn("FIELDS: %s" % fields) + #DumperBase.warn("FIELDS: %s" % fields) res = [] for field in fields: if isinstance(field, self.dumper.Value): - #warn("USING VALUE DIRECTLY %s" % field.name) + #DumperBase.warn("USING VALUE DIRECTLY %s" % field.name) res.append(field) continue if field.isBase and not includeBases: - #warn("DROPPING BASE %s" % field.name) + #DumperBase.warn("DROPPING BASE %s" % field.name) continue res.append(self.extractField(field)) - #warn("GOT MEMBERS: %s" % res) + #DumperBase.warn("GOT MEMBERS: %s" % res) return res def __add__(self, other): self.check() if self.dumper.isInt(other): stripped = self.type.stripTypedefs() - if stripped.code == TypeCodePointer: + if stripped.code == TypeCode.TypeCodePointer: address = self.pointer() + stripped.dereference().size() * other val = self.dumper.Value(self.dumper) val.laddress = None val.ldata = bytes(struct.pack(self.dumper.packCode + 'Q', address)) val.type = self.type return val - error('BAD DATA TO ADD TO: %s %s' % (self.type, other)) + raise RuntimeError('BAD DATA TO ADD TO: %s %s' % (self.type, other)) def __sub__(self, other): self.check() if self.type.name == other.type.name: stripped = self.type.stripTypedefs() - if stripped.code == TypeCodePointer: + if stripped.code == TypeCode.TypeCodePointer: return (self.pointer() - other.pointer()) // stripped.dereference().size() - error('BAD DATA TO SUB TO: %s %s' % (self.type, other)) + raise RuntimeError('BAD DATA TO SUB TO: %s %s' % (self.type, other)) def dereference(self): self.check() - if self.type.code == TypeCodeTypedef: + if self.type.code == TypeCode.TypeCodeTypedef: return self.detypedef().dereference() val = self.dumper.Value(self.dumper) - if self.type.code in (TypeCodeReference, TypeCodeRValueReference): + if self.type.code in (TypeCode.TypeCodeReference, TypeCode.TypeCodeRValueReference): val.summary = self.summary if self.nativeValue is None: val.laddress = self.pointer() @@ -3271,16 +3168,16 @@ class DumperBase: val.type = self.dumper.nativeDynamicType(val.laddress, self.type.dereference()) else: val = self.dumper.nativeValueDereferenceReference(self) - elif self.type.code == TypeCodePointer: + elif self.type.code == TypeCode.TypeCodePointer: if self.nativeValue is None: val.laddress = self.pointer() val.type = self.dumper.nativeDynamicType(val.laddress, self.type.dereference()) else: val = self.dumper.nativeValueDereferencePointer(self) else: - error("WRONG: %s" % self.type.code) - #warn("DEREFERENCING FROM: %s" % self) - #warn("DEREFERENCING TO: %s" % val) + raise RuntimeError("WRONG: %s" % self.type.code) + #DumperBase.warn("DEREFERENCING FROM: %s" % self) + #DumperBase.warn("DEREFERENCING TO: %s" % val) #dynTypeName = val.type.dynamicTypeName(val.laddress) #if dynTypeName is not None: # val.type = self.dumper.createType(dynTypeName) @@ -3288,12 +3185,12 @@ class DumperBase: def detypedef(self): self.check() - if self.type.code != TypeCodeTypedef: - error("WRONG") + if self.type.code != TypeCode.TypeCodeTypedef: + raise RuntimeError("WRONG") val = self.copy() val.type = self.type.ltarget - #warn("DETYPEDEF FROM: %s" % self) - #warn("DETYPEDEF TO: %s" % val) + #DumperBase.warn("DETYPEDEF FROM: %s" % self) + #DumperBase.warn("DETYPEDEF TO: %s" % val) return val def extend(self, size): @@ -3304,7 +3201,7 @@ class DumperBase: return val if self.type.size() == size: return self - error('NOT IMPLEMENTED') + raise RuntimeError('NOT IMPLEMENTED') def zeroExtend(self, data, size): ext = '\0' * (size - len(data)) @@ -3337,7 +3234,7 @@ class DumperBase: return self.ldata if size < len(self.ldata): return self.ldata[:size] - #error('ZERO-EXTENDING DATA TO %s BYTES: %s' % (size, self)) + #raise RuntimeError('ZERO-EXTENDING DATA TO %s BYTES: %s' % (size, self)) return self.zeroExtend(self.ldata, size) if self.laddress is not None: if size is None: @@ -3345,8 +3242,8 @@ class DumperBase: res = self.dumper.readRawMemory(self.laddress, size) if len(res) > 0: return res - error('CANNOT CONVERT ADDRESS TO BYTES: %s' % self) - error('CANNOT CONVERT TO BYTES: %s' % self) + raise RuntimeError('CANNOT CONVERT ADDRESS TO BYTES: %s' % self) + raise RuntimeError('CANNOT CONVERT TO BYTES: %s' % self) def extractInteger(self, bitsize, unsigned): #with self.dumper.timer('extractInt'): @@ -3365,7 +3262,7 @@ class DumperBase: code = 'B' if unsigned else 'b' rawBytes = self.data(size) res = struct.unpack_from(self.dumper.packCode + code, rawBytes, 0)[0] - #warn('Extract: Code: %s Bytes: %s Bitsize: %s Size: %s' + #DumperBase.warn('Extract: Code: %s Bytes: %s Bitsize: %s Size: %s' # % (self.dumper.packCode + code, self.dumper.hexencode(rawBytes), bitsize, size)) return res @@ -3382,25 +3279,25 @@ class DumperBase: def split(self, pattern): #with self.dumper.timer('split'): - #warn('EXTRACT STRUCT FROM: %s' % self.type) + #DumperBase.warn('EXTRACT STRUCT FROM: %s' % self.type) (pp, size, fields) = self.dumper.describeStruct(pattern) - #warn('SIZE: %s ' % size) + #DumperBase.warn('SIZE: %s ' % size) result = struct.unpack_from(self.dumper.packCode + pp, self.data(size)) def structFixer(field, thing): - #warn('STRUCT MEMBER: %s' % type(thing)) + #DumperBase.warn('STRUCT MEMBER: %s' % type(thing)) if field.isStruct: #if field.type != field.fieldType(): - # error('DO NOT SIMPLIFY') - #warn('FIELD POS: %s' % field.type.stringify()) - #warn('FIELD TYE: %s' % field.fieldType().stringify()) + # raise RuntimeError('DO NOT SIMPLIFY') + #DumperBase.warn('FIELD POS: %s' % field.type.stringify()) + #DumperBase.warn('FIELD TYE: %s' % field.fieldType().stringify()) res = self.dumper.createValue(thing, field.fieldType()) - #warn('RES TYPE: %s' % res.type) + #DumperBase.warn('RES TYPE: %s' % res.type) if self.laddress is not None: res.laddress = self.laddress + field.offset() return res return thing if len(fields) != len(result): - error('STRUCT ERROR: %s %s' % (fields, result)) + raise RuntimeError('STRUCT ERROR: %s %s' % (fields, result)) return tuple(map(structFixer, fields, result)) def checkPointer(self, p, align = 1): @@ -3424,14 +3321,14 @@ class DumperBase: return (type_name[0:pos1].strip(), type_name[pos2+1:].strip(), int(item_count)) def registerType(self, typeId, tdata): - #warn('REGISTER TYPE: %s' % typeId) + #DumperBase.warn('REGISTER TYPE: %s' % typeId) self.typeData[typeId] = tdata #typeId = typeId.replace(' ', '') #self.typeData[typeId] = tdata - #warn('REGISTERED: %s' % self.typeData) + #DumperBase.warn('REGISTERED: %s' % self.typeData) def registerTypeAlias(self, existingTypeId, aliasId): - #warn('REGISTER ALIAS %s FOR %s' % (aliasId, existingTypeId)) + #DumperBase.warn('REGISTER ALIAS %s FOR %s' % (aliasId, existingTypeId)) self.typeData[aliasId] = self.typeData[existingTypeId] class TypeData: @@ -3475,13 +3372,13 @@ class DumperBase: def typeData(self): tdata = self.dumper.typeData.get(self.typeId, None) if tdata is not None: - #warn('USING : %s' % self.typeId) + #DumperBase.warn('USING : %s' % self.typeId) return tdata typeId = self.typeId.replace(' ', '') if tdata is not None: - #warn('USING FALLBACK : %s' % self.typeId) + #DumperBase.warn('USING FALLBACK : %s' % self.typeId) return tdata - #warn('EXPANDING LAZILY: %s' % self.typeId) + #DumperBase.warn('EXPANDING LAZILY: %s' % self.typeId) self.dumper.lookupType(self.typeId) return self.dumper.typeData.get(self.typeId) @@ -3522,19 +3419,19 @@ class DumperBase: def __getitem__(self, index): if self.dumper.isInt(index): return self.templateArgument(index) - error('CANNOT INDEX TYPE') + raise RuntimeError('CANNOT INDEX TYPE') def dynamicTypeName(self, address): tdata = self.typeData() if tdata is None: return None - if tdata.code != TypeCodeStruct: + if tdata.code != TypeCode.TypeCodeStruct: return None try: vtbl = self.dumper.extractPointer(address) except: return None - #warn('VTBL: 0x%x' % vtbl) + #DumperBase.warn('VTBL: 0x%x' % vtbl) if not self.dumper.couldBePointer(vtbl): return None return self.dumper.nativeDynamicTypeName(address, self) @@ -3552,12 +3449,12 @@ class DumperBase: def check(self): tdata = self.typeData() if tdata is None: - error('TYPE WITHOUT DATA: %s ALL: %s' % (self.typeId, self.dumper.typeData.keys())) + raise RuntimeError('TYPE WITHOUT DATA: %s ALL: %s' % (self.typeId, self.dumper.typeData.keys())) if tdata.name is None: - error('TYPE WITHOUT NAME: %s' % self.typeId) + raise RuntimeError('TYPE WITHOUT NAME: %s' % self.typeId) def dereference(self): - if self.code == TypeCodeTypedef: + if self.code == TypeCode.TypeCodeTypedef: return self.ltarget.dereference() self.check() return self.ltarget @@ -3573,18 +3470,18 @@ class DumperBase: def templateArgument(self, position): tdata = self.typeData() - #warn('TDATA: %s' % tdata) - #warn('ID: %s' % self.typeId) + #DumperBase.warn('TDATA: %s' % tdata) + #DumperBase.warn('ID: %s' % self.typeId) if tdata is None: # Native lookups didn't help. Happens for 'wrong' placement of 'const' # etc. with LLDB. But not all is lost: ta = self.dumper.listTemplateParameters(self.typeId) - #warn('MANUAL: %s' % ta) + #DumperBase.warn('MANUAL: %s' % ta) res = ta[position] - #warn('RES: %s' % res.typeId) + #DumperBase.warn('RES: %s' % res.typeId) return res - #warn('TA: %s %s' % (position, self.typeId)) - #warn('ARGS: %s' % tdata.templateArguments) + #DumperBase.warn('TA: %s %s' % (position, self.typeId)) + #DumperBase.warn('ARGS: %s' % tdata.templateArguments) return tdata.templateArguments[position] def simpleEncoding(self): @@ -3605,18 +3502,18 @@ class DumperBase: return res def isSimpleType(self): - return self.code in (TypeCodeIntegral, TypeCodeFloat, TypeCodeEnum) + return self.code in (TypeCode.TypeCodeIntegral, TypeCode.TypeCodeFloat, TypeCode.TypeCodeEnum) def alignment(self): tdata = self.typeData() - if tdata.code == TypeCodeTypedef: + if tdata.code == TypeCode.TypeCodeTypedef: return tdata.ltarget.alignment() - if tdata.code in (TypeCodeIntegral, TypeCodeFloat, TypeCodeEnum): + if tdata.code in (TypeCode.TypeCodeIntegral, TypeCode.TypeCodeFloat, TypeCode.TypeCodeEnum): if tdata.name in ('double', 'long long', 'unsigned long long'): # Crude approximation. return 8 if self.dumper.isWindowsTarget() else self.dumper.ptrSize() return self.size() - if tdata.code in (TypeCodePointer, TypeCodeReference, TypeCodeRValueReference): + if tdata.code in (TypeCode.TypeCodePointer, TypeCode.TypeCodeReference, TypeCode.TypeCodeRValueReference): return self.dumper.ptrSize() if tdata.lalignment is not None: #if isinstance(tdata.lalignment, function): # Does not work that way. @@ -3632,24 +3529,24 @@ class DumperBase: return self.typeData().ltarget def stripTypedefs(self): - if isinstance(self, self.dumper.Type) and self.code != TypeCodeTypedef: - #warn('NO TYPEDEF: %s' % self) + if isinstance(self, self.dumper.Type) and self.code != TypeCode.TypeCodeTypedef: + #DumperBase.warn('NO TYPEDEF: %s' % self) return self return self.ltarget def size(self): bs = self.bitsize() if bs % 8 != 0: - warn('ODD SIZE: %s' % self) + DumperBase.warn('ODD SIZE: %s' % self) return (7 + bs) >> 3 def bitsize(self): if self.lbitsize is not None: return self.lbitsize - error('DONT KNOW SIZE: %s' % self) + raise RuntimeError('DONT KNOW SIZE: %s' % self) def isMovableType(self): - if self.code in (TypeCodePointer, TypeCodeIntegral, TypeCodeFloat): + if self.code in (TypeCode.TypeCodePointer, TypeCode.TypeCodeIntegral, TypeCode.TypeCodeFloat): return True strippedName = self.dumper.stripNamespaceFromType(self.name) if strippedName in ( @@ -3704,7 +3601,7 @@ class DumperBase: def fieldType(self): if self.type is not None: return self.type - error('CANT GET FIELD TYPE FOR %s' % self) + raise RuntimeError('CANT GET FIELD TYPE FOR %s' % self) return None def ptrCode(self): @@ -3712,7 +3609,7 @@ class DumperBase: def toPointerData(self, address): if not self.isInt(address): - error('wrong') + raise RuntimeError('wrong') return bytes(struct.pack(self.packCode + self.ptrCode(), address)) def fromPointerData(self, bytes_value): @@ -3720,10 +3617,10 @@ class DumperBase: def createPointerValue(self, targetAddress, targetTypish): if not isinstance(targetTypish, self.Type) and not isinstance(targetTypish, str): - error('Expected type in createPointerValue(), got %s' + raise RuntimeError('Expected type in createPointerValue(), got %s' % type(targetTypish)) if not self.isInt(targetAddress): - error('Expected integral address value in createPointerValue(), got %s' + raise RuntimeError('Expected integral address value in createPointerValue(), got %s' % type(targetTypish)) val = self.Value(self) val.ldata = self.toPointerData(targetAddress) @@ -3733,10 +3630,10 @@ class DumperBase: def createReferenceValue(self, targetAddress, targetType): if not isinstance(targetType, self.Type): - error('Expected type in createReferenceValue(), got %s' + raise RuntimeError('Expected type in createReferenceValue(), got %s' % type(targetType)) if not self.isInt(targetAddress): - error('Expected integral address value in createReferenceValue(), got %s' + raise RuntimeError('Expected integral address value in createReferenceValue(), got %s' % type(targetType)) val = self.Value(self) val.ldata = self.toPointerData(targetAddress) @@ -3746,27 +3643,27 @@ class DumperBase: def createPointerType(self, targetType): if not isinstance(targetType, self.Type): - error('Expected type in createPointerType(), got %s' + raise RuntimeError('Expected type in createPointerType(), got %s' % type(targetType)) typeId = targetType.typeId + ' *' tdata = self.TypeData(self) tdata.name = targetType.name + '*' tdata.typeId = typeId tdata.lbitsize = 8 * self.ptrSize() - tdata.code = TypeCodePointer + tdata.code = TypeCode.TypeCodePointer tdata.ltarget = targetType self.registerType(typeId, tdata) return self.Type(self, typeId) def createReferenceType(self, targetType): if not isinstance(targetType, self.Type): - error('Expected type in createReferenceType(), got %s' + raise RuntimeError('Expected type in createReferenceType(), got %s' % type(targetType)) typeId = targetType.typeId + ' &' tdata = self.TypeData(self) tdata.name = targetType.name + ' &' tdata.typeId = typeId - tdata.code = TypeCodeReference + tdata.code = TypeCode.TypeCodeReference tdata.ltarget = targetType tdata.lbitsize = 8 * self.ptrSize() # Needed for Gdb13393 test. #tdata.lbitsize = None @@ -3775,13 +3672,13 @@ class DumperBase: def createRValueReferenceType(self, targetType): if not isinstance(targetType, self.Type): - error('Expected type in createRValueReferenceType(), got %s' + raise RuntimeError('Expected type in createRValueReferenceType(), got %s' % type(targetType)) typeId = targetType.typeId + ' &&' tdata = self.TypeData(self) tdata.name = targetType.name + ' &&' tdata.typeId = typeId - tdata.code = TypeCodeRValueReference + tdata.code = TypeCode.TypeCodeRValueReference tdata.ltarget = targetType tdata.lbitsize = None self.registerType(typeId, tdata) @@ -3789,7 +3686,7 @@ class DumperBase: def createArrayType(self, targetType, count): if not isinstance(targetType, self.Type): - error('Expected type in createArrayType(), got %s' + raise RuntimeError('Expected type in createArrayType(), got %s' % type(targetType)) targetTypeId = targetType.typeId @@ -3804,7 +3701,7 @@ class DumperBase: tdata = self.TypeData(self) tdata.name = type_name tdata.typeId = type_id - tdata.code = TypeCodeArray + tdata.code = TypeCode.TypeCodeArray tdata.ltarget = targetType tdata.lbitsize = targetType.lbitsize * count self.registerType(type_id, tdata) @@ -3812,13 +3709,13 @@ class DumperBase: def createBitfieldType(self, targetType, bitsize): if not isinstance(targetType, self.Type): - error('Expected type in createBitfieldType(), got %s' + raise RuntimeError('Expected type in createBitfieldType(), got %s' % type(targetType)) typeId = '%s:%d' % (targetType.typeId, bitsize) tdata = self.TypeData(self) tdata.name = '%s : %d' % (targetType.typeId, bitsize) tdata.typeId = typeId - tdata.code = TypeCodeBitfield + tdata.code = TypeCode.TypeCodeBitfield tdata.ltarget = targetType tdata.lbitsize = bitsize self.registerType(typeId, tdata) @@ -3828,7 +3725,7 @@ class DumperBase: if typeId is None: typeId = typeName if not isinstance(targetType, self.Type): - error('Expected type in createTypedefType(), got %s' + raise RuntimeError('Expected type in createTypedefType(), got %s' % type(targetType)) # Happens for C-style struct in GDB: typedef { int x; } struct S1; if targetType.typeId == typeId: @@ -3836,7 +3733,7 @@ class DumperBase: tdata = self.TypeData(self) tdata.name = typeName tdata.typeId = typeId - tdata.code = TypeCodeTypedef + tdata.code = TypeCode.TypeCodeTypedef tdata.ltarget = targetType tdata.lbitsize = targetType.lbitsize #tdata.lfields = targetType.lfields @@ -3889,12 +3786,12 @@ class DumperBase: return self.Type(self, typish) knownType = self.lookupType(typish) - #warn('KNOWN: %s' % knownType) + #DumperBase.warn('KNOWN: %s' % knownType) if knownType is not None: - #warn('USE FROM NATIVE') + #DumperBase.warn('USE FROM NATIVE') return knownType - #warn('FAKING: %s SIZE: %s' % (typish, size)) + #DumperBase.warn('FAKING: %s SIZE: %s' % (typish, size)) tdata = self.TypeData(self) tdata.name = typish tdata.typeId = typish @@ -3903,25 +3800,25 @@ class DumperBase: tdata.lbitsize = 8 * size self.registerType(typish, tdata) typeobj = self.Type(self, typish) - #warn('CREATE TYPE: %s' % typeobj.stringify()) + #DumperBase.warn('CREATE TYPE: %s' % typeobj.stringify()) typeobj.check() return typeobj - error('NEED TYPE, NOT %s' % type(typish)) + raise RuntimeError('NEED TYPE, NOT %s' % type(typish)) def createValue(self, datish, typish): val = self.Value(self) val.type = self.createType(typish) if self.isInt(datish): # Used as address. - #warn('CREATING %s AT 0x%x' % (val.type.name, datish)) + #DumperBase.warn('CREATING %s AT 0x%x' % (val.type.name, datish)) val.laddress = datish val.type = val.type.dynamicType(datish) return val if isinstance(datish, bytes): - #warn('CREATING %s WITH DATA %s' % (val.type.name, self.hexencode(datish))) + #DumperBase.warn('CREATING %s WITH DATA %s' % (val.type.name, self.hexencode(datish))) val.ldata = datish val.check() return val - error('EXPECTING ADDRESS OR BYTES, GOT %s' % type(datish)) + raise RuntimeError('EXPECTING ADDRESS OR BYTES, GOT %s' % type(datish)) def createContainerItem(self, data, innerTypish, container): innerType = self.createType(innerTypish) @@ -3966,7 +3863,7 @@ class DumperBase: if self.autoPadNext: self.currentBitsize = 8 * ((self.currentBitsize + 7) >> 3) # Fill up byte. padding = (fieldAlign - (self.currentBitsize >> 3)) % fieldAlign - #warn('AUTO PADDING AT %s BITS BY %s BYTES' % (self.currentBitsize, padding)) + #DumperBase.warn('AUTO PADDING AT %s BITS BY %s BYTES' % (self.currentBitsize, padding)) field = self.dumper.Field(self.dumper, bitpos=self.currentBitsize, bitsize=padding*8) self.pattern += '%ds' % padding @@ -3976,7 +3873,7 @@ class DumperBase: if fieldAlign > self.maxAlign: self.maxAlign = fieldAlign - #warn("MAX ALIGN: %s" % self.maxAlign) + #DumperBase.warn("MAX ALIGN: %s" % self.maxAlign) field = self.dumper.Field(dumper=self.dumper, name=fieldName, type=fieldType, isStruct=fieldIsStruct, bitpos=self.currentBitsize, @@ -4046,7 +3943,7 @@ class DumperBase: builder.fields.append(field) n = None else: - error('UNKNOWN STRUCT CODE: %s' % c) + raise RuntimeError('UNKNOWN STRUCT CODE: %s' % c) pp = builder.pattern size = (builder.currentBitsize + 7) >> 3 fields = builder.fields diff --git a/share/qtcreator/debugger/gdbbridge.py b/share/qtcreator/debugger/gdbbridge.py index 6a912ea388d..d58ed75384d 100644 --- a/share/qtcreator/debugger/gdbbridge.py +++ b/share/qtcreator/debugger/gdbbridge.py @@ -38,7 +38,7 @@ import tempfile import types from dumper import * - +from utils import TypeCode ####################################################################### # @@ -168,7 +168,7 @@ def importPlainDumpers(args): gdb.execute('disable pretty-printer .* .*') except: # Might occur in non-ASCII directories - warn('COULD NOT DISABLE PRETTY PRINTERS') + DumperBase.warn('COULD NOT DISABLE PRETTY PRINTERS') else: theDumper.importPlainDumpers() @@ -186,7 +186,7 @@ class OutputSaver: def __exit__(self, exType, exValue, exTraceBack): if self.d.passExceptions and not exType is None: - showException('OUTPUTSAVER', exType, exValue, exTraceBack) + self.d.showException('OUTPUTSAVER', exType, exValue, exTraceBack) self.d.output = self.savedOutput else: self.savedOutput += self.d.output @@ -217,7 +217,7 @@ class Dumper(DumperBase): self.setVariableFetchingOptions(args) def fromFrameValue(self, nativeValue): - #warn('FROM FRAME VALUE: %s' % nativeValue.address) + #DumperBase.warn('FROM FRAME VALUE: %s' % nativeValue.address) val = nativeValue try: val = nativeValue.cast(nativeValue.dynamic_type) @@ -226,7 +226,7 @@ class Dumper(DumperBase): return self.fromNativeValue(val) def fromNativeValue(self, nativeValue): - #warn('FROM NATIVE VALUE: %s' % nativeValue) + #DumperBase.warn('FROM NATIVE VALUE: %s' % nativeValue) self.check(isinstance(nativeValue, gdb.Value)) nativeType = nativeValue.type code = nativeType.code @@ -234,7 +234,7 @@ class Dumper(DumperBase): targetType = self.fromNativeType(nativeType.target().unqualified()) val = self.createReferenceValue(toInteger(nativeValue.address), targetType) val.nativeValue = nativeValue - #warn('CREATED REF: %s' % val) + #DumperBase.warn('CREATED REF: %s' % val) return val if code == gdb.TYPE_CODE_PTR: try: @@ -248,14 +248,14 @@ class Dumper(DumperBase): # later which # is surprisingly expensive. val.nativeValue = nativeValue - #warn('CREATED PTR 1: %s' % val) + #DumperBase.warn('CREATED PTR 1: %s' % val) if not nativeValue.address is None: val.laddress = toInteger(nativeValue.address) - #warn('CREATED PTR 2: %s' % val) + #DumperBase.warn('CREATED PTR 2: %s' % val) return val if code == gdb.TYPE_CODE_TYPEDEF: targetType = nativeType.strip_typedefs().unqualified() - #warn('TARGET TYPE: %s' % targetType) + #DumperBase.warn('TARGET TYPE: %s' % targetType) if targetType.code == gdb.TYPE_CODE_ARRAY: val = self.Value(self) else: @@ -267,7 +267,7 @@ class Dumper(DumperBase): val = self.fromNativeValue(nativeValue.cast(targetType)) except: val = self.Value(self) - #warn('CREATED TYPEDEF: %s' % val) + #DumperBase.warn('CREATED TYPEDEF: %s' % val) else: val = self.Value(self) @@ -308,34 +308,34 @@ class Dumper(DumperBase): def fromNativeType(self, nativeType): self.check(isinstance(nativeType, gdb.Type)) code = nativeType.code - #warn('FROM NATIVE TYPE: %s' % nativeType) + #DumperBase.warn('FROM NATIVE TYPE: %s' % nativeType) nativeType = nativeType.unqualified() if code == gdb.TYPE_CODE_PTR: - #warn('PTR') + #DumperBase.warn('PTR') targetType = self.fromNativeType(nativeType.target().unqualified()) return self.createPointerType(targetType) if code == gdb.TYPE_CODE_REF: - #warn('REF') + #DumperBase.warn('REF') targetType = self.fromNativeType(nativeType.target().unqualified()) return self.createReferenceType(targetType) if hasattr(gdb, "TYPE_CODE_RVALUE_REF"): if code == gdb.TYPE_CODE_RVALUE_REF: - #warn('RVALUEREF') + #DumperBase.warn('RVALUEREF') targetType = self.fromNativeType(nativeType.target()) return self.createRValueReferenceType(targetType) if code == gdb.TYPE_CODE_ARRAY: - #warn('ARRAY') + #DumperBase.warn('ARRAY') nativeTargetType = nativeType.target().unqualified() targetType = self.fromNativeType(nativeTargetType) count = nativeType.sizeof // nativeTargetType.sizeof return self.createArrayType(targetType, count) if code == gdb.TYPE_CODE_TYPEDEF: - #warn('TYPEDEF') + #DumperBase.warn('TYPEDEF') nativeTargetType = nativeType.unqualified() while nativeTargetType.code == gdb.TYPE_CODE_TYPEDEF: nativeTargetType = nativeTargetType.strip_typedefs().unqualified() @@ -344,7 +344,7 @@ class Dumper(DumperBase): self.nativeTypeId(nativeType)) if code == gdb.TYPE_CODE_ERROR: - warn('Type error: %s' % nativeType) + self.warn('Type error: %s' % nativeType) return self.Type(self, '') typeId = self.nativeTypeId(nativeType) @@ -356,28 +356,28 @@ class Dumper(DumperBase): tdata.lbitsize = nativeType.sizeof * 8 tdata.code = { #gdb.TYPE_CODE_TYPEDEF : TypeCodeTypedef, # Handled above. - gdb.TYPE_CODE_METHOD : TypeCodeFunction, - gdb.TYPE_CODE_VOID : TypeCodeVoid, - gdb.TYPE_CODE_FUNC : TypeCodeFunction, - gdb.TYPE_CODE_METHODPTR : TypeCodeFunction, - gdb.TYPE_CODE_MEMBERPTR : TypeCodeFunction, - #gdb.TYPE_CODE_PTR : TypeCodePointer, # Handled above. - #gdb.TYPE_CODE_REF : TypeCodeReference, # Handled above. - gdb.TYPE_CODE_BOOL : TypeCodeIntegral, - gdb.TYPE_CODE_CHAR : TypeCodeIntegral, - gdb.TYPE_CODE_INT : TypeCodeIntegral, - gdb.TYPE_CODE_FLT : TypeCodeFloat, - gdb.TYPE_CODE_ENUM : TypeCodeEnum, - #gdb.TYPE_CODE_ARRAY : TypeCodeArray, - gdb.TYPE_CODE_STRUCT : TypeCodeStruct, - gdb.TYPE_CODE_UNION : TypeCodeStruct, - gdb.TYPE_CODE_COMPLEX : TypeCodeComplex, - gdb.TYPE_CODE_STRING : TypeCodeFortranString, + gdb.TYPE_CODE_METHOD : TypeCode.TypeCodeFunction, + gdb.TYPE_CODE_VOID : TypeCode.TypeCodeVoid, + gdb.TYPE_CODE_FUNC : TypeCode.TypeCodeFunction, + gdb.TYPE_CODE_METHODPTR : TypeCode.TypeCodeFunction, + gdb.TYPE_CODE_MEMBERPTR : TypeCode.TypeCodeFunction, + #gdb.TYPE_CODE_PTR : TypeCode.TypeCodePointer, # Handled above. + #gdb.TYPE_CODE_REF : TypeCode.TypeCodeReference, # Handled above. + gdb.TYPE_CODE_BOOL : TypeCode.TypeCodeIntegral, + gdb.TYPE_CODE_CHAR : TypeCode.TypeCodeIntegral, + gdb.TYPE_CODE_INT : TypeCode.TypeCodeIntegral, + gdb.TYPE_CODE_FLT : TypeCode.TypeCodeFloat, + gdb.TYPE_CODE_ENUM : TypeCode.TypeCodeEnum, + #gdb.TYPE_CODE_ARRAY : TypeCode.TypeCodeArray, + gdb.TYPE_CODE_STRUCT : TypeCode.TypeCodeStruct, + gdb.TYPE_CODE_UNION : TypeCode.TypeCodeStruct, + gdb.TYPE_CODE_COMPLEX : TypeCode.TypeCodeComplex, + gdb.TYPE_CODE_STRING : TypeCode.TypeCodeFortranString, }[code] - if tdata.code == TypeCodeEnum: + if tdata.code == TypeCode.TypeCodeEnum: tdata.enumDisplay = lambda intval, addr, form : \ self.nativeTypeEnumDisplay(nativeType, intval, form) - if tdata.code == TypeCodeStruct: + if tdata.code == TypeCode.TypeCodeStruct: tdata.lalignment = lambda : \ self.nativeStructAlignment(nativeType) tdata.lfields = lambda value : \ @@ -402,7 +402,7 @@ class Dumper(DumperBase): elif isinstance(targ, gdb.Value): targs.append(self.fromNativeValue(targ).value()) else: - error('UNKNOWN TEMPLATE PARAMETER') + raise RuntimeError('UNKNOWN TEMPLATE PARAMETER') pos += 1 targs2 = self.listTemplateParametersManually(str(nativeType)) return targs if len(targs) >= len(targs2) else targs2 @@ -451,7 +451,7 @@ class Dumper(DumperBase): return typeId def nativeStructAlignment(self, nativeType): - #warn('NATIVE ALIGN FOR %s' % nativeType.name) + #DumperBase.warn('NATIVE ALIGN FOR %s' % nativeType.name) def handleItem(nativeFieldType, align): a = self.fromNativeType(nativeFieldType).alignment() return a if a > align else align @@ -507,7 +507,7 @@ class Dumper(DumperBase): anonNumber = 0 - #warn('LISTING FIELDS FOR %s' % nativeType) + #DumperBase.warn('LISTING FIELDS FOR %s' % nativeType) for nativeField in nativeType.fields(): fieldName = nativeField.name # Something without a name. @@ -521,7 +521,7 @@ class Dumper(DumperBase): # multiple anonymous unions in the struct. anonNumber += 1 fieldName = '#%s' % anonNumber - #warn('FIELD: %s' % fieldName) + #DumperBase.warn('FIELD: %s' % fieldName) # hasattr(nativeField, 'bitpos') == False indicates a static field, # but if we have access to a nativeValue .fromNativeField will # also succeed. We essentially skip only static members from @@ -531,8 +531,8 @@ class Dumper(DumperBase): def fromNativeField(self, nativeField, nativeValue, fieldName): nativeFieldType = nativeField.type.unqualified() - #warn(' TYPE: %s' % nativeFieldType) - #warn(' TYPEID: %s' % self.nativeTypeId(nativeFieldType)) + #DumperBase.warn(' TYPE: %s' % nativeFieldType) + #DumperBase.warn(' TYPEID: %s' % self.nativeTypeId(nativeFieldType)) if hasattr(nativeField, 'bitpos'): bitpos = nativeField.bitpos @@ -562,7 +562,7 @@ class Dumper(DumperBase): capturedFieldName, value) - #warn("FOUND NATIVE FIELD: %s bitpos: %s" % (fieldName, bitpos)) + #DumperBase.warn("FOUND NATIVE FIELD: %s bitpos: %s" % (fieldName, bitpos)) return self.Field(dumper=self, name=fieldName, isBase=nativeField.is_base_class, bitsize=bitsize, bitpos=bitpos, type=fieldType, extractor=extractor) @@ -574,19 +574,19 @@ class Dumper(DumperBase): try: block = frame.block() - #warn('BLOCK: %s ' % block) + #DumperBase.warn('BLOCK: %s ' % block) except RuntimeError as error: - #warn('BLOCK IN FRAME NOT ACCESSIBLE: %s' % error) + #DumperBase.warn('BLOCK IN FRAME NOT ACCESSIBLE: %s' % error) return [] except: - warn('BLOCK NOT ACCESSIBLE FOR UNKNOWN REASONS') + self.warn('BLOCK NOT ACCESSIBLE FOR UNKNOWN REASONS') return [] items = [] shadowed = {} while True: if block is None: - warn("UNEXPECTED 'None' BLOCK") + self.warn("UNEXPECTED 'None' BLOCK") break for symbol in block: @@ -602,12 +602,12 @@ class Dumper(DumperBase): # 'NotImplementedError: Symbol type not yet supported in # Python scripts.' - #warn('SYMBOL %s (%s, %s)): ' % (symbol, name, symbol.name)) + #DumperBase.warn('SYMBOL %s (%s, %s)): ' % (symbol, name, symbol.name)) if self.passExceptions and not self.isTesting: nativeValue = frame.read_var(name, block) value = self.fromFrameValue(nativeValue) value.name = name - #warn('READ 0: %s' % value.stringify()) + #DumperBase.warn('READ 0: %s' % value.stringify()) items.append(value) continue @@ -616,14 +616,14 @@ class Dumper(DumperBase): nativeValue = frame.read_var(name, block) value = self.fromFrameValue(nativeValue) value.name = name - #warn('READ 1: %s' % value.stringify()) + #DumperBase.warn('READ 1: %s' % value.stringify()) items.append(value) continue except: pass try: - #warn('READ 2: %s' % item.value) + #DumperBase.warn('READ 2: %s' % item.value) value = self.fromFrameValue(frame.read_var(name)) value.name = name items.append(value) @@ -637,8 +637,8 @@ class Dumper(DumperBase): pass try: - #warn('READ 3: %s %s' % (name, item.value)) - #warn('ITEM 3: %s' % item.value) + #DumperBase.warn('READ 3: %s %s' % (name, item.value)) + #DumperBase.warn('ITEM 3: %s' % item.value) value = self.fromFrameValue(gdb.parse_and_eval(name)) value.name = name items.append(value) @@ -685,7 +685,7 @@ class Dumper(DumperBase): partialName = partialVar.split('.')[1].split('@')[0] if isPartial else None variables = self.listLocals(partialName) - #warn('VARIABLES: %s' % variables) + #DumperBase.warn('VARIABLES: %s' % variables) # Take care of the return value of the last function call. if len(self.resultVarName) > 0: @@ -728,13 +728,13 @@ class Dumper(DumperBase): return None if val is None else self.fromNativeValue(val) def nativeParseAndEvaluate(self, exp): - #warn('EVALUATE "%s"' % exp) + #DumperBase.warn('EVALUATE "%s"' % exp) try: val = gdb.parse_and_eval(exp) return val except RuntimeError as error: if self.passExceptions: - warn("Cannot evaluate '%s': %s" % (exp, error)) + self.warn("Cannot evaluate '%s': %s" % (exp, error)) return None def callHelper(self, rettype, value, function, args): @@ -749,7 +749,7 @@ class Dumper(DumperBase): else: arg += a - #warn('CALL: %s -> %s(%s)' % (value, function, arg)) + #DumperBase.warn('CALL: %s -> %s(%s)' % (value, function, arg)) typeName = value.type.name if typeName.find(':') >= 0: typeName = "'" + typeName + "'" @@ -758,11 +758,11 @@ class Dumper(DumperBase): addr = value.address() if addr is None: addr = self.pokeValue(value) - #warn('PTR: %s -> %s(%s)' % (value, function, addr)) + #DumperBase.warn('PTR: %s -> %s(%s)' % (value, function, addr)) exp = '((%s*)0x%x)->%s(%s)' % (typeName, addr, function, arg) - #warn('CALL: %s' % exp) + #DumperBase.warn('CALL: %s' % exp) result = gdb.parse_and_eval(exp) - #warn(' -> %s' % result) + #DumperBase.warn(' -> %s' % result) res = self.fromNativeValue(result) if value.address() is None: self.releaseValue(addr) @@ -770,9 +770,9 @@ class Dumper(DumperBase): def makeExpression(self, value): typename = '::' + value.type.name - #warn(' TYPE: %s' % typename) + #DumperBase.warn(' TYPE: %s' % typename) exp = '(*(%s*)(0x%x))' % (typename, value.address()) - #warn(' EXP: %s' % exp) + #DumperBase.warn(' EXP: %s' % exp) return exp def makeStdString(init): @@ -790,13 +790,13 @@ class Dumper(DumperBase): size = value.type.size() data = value.data() h = self.hexencode(data) - #warn('DATA: %s' % h) + #DumperBase.warn('DATA: %s' % h) string = ''.join('\\x' + h[2*i:2*i+2] for i in range(size)) exp = '(%s*)memcpy(calloc(%d, 1), "%s", %d)' \ % (value.type.name, size, string, size) - #warn('EXP: %s' % exp) + #DumperBase.warn('EXP: %s' % exp) res = gdb.parse_and_eval(exp) - #warn('RES: %s' % res) + #DumperBase.warn('RES: %s' % res) return toInteger(res) def releaseValue(self, address): @@ -824,7 +824,7 @@ class Dumper(DumperBase): return self.cachedInferior def readRawMemory(self, address, size): - #warn('READ: %s FROM 0x%x' % (size, address)) + #DumperBase.warn('READ: %s FROM 0x%x' % (size, address)) if address == 0 or size == 0: return bytes() res = self.selectedInferior().read_memory(address, size) @@ -1185,7 +1185,7 @@ class Dumper(DumperBase): def lookupNativeTypeHelper(self, typeName): typeobj = self.typeCache.get(typeName) - #warn('LOOKUP 1: %s -> %s' % (typeName, typeobj)) + #DumperBase.warn('LOOKUP 1: %s -> %s' % (typeName, typeobj)) if not typeobj is None: return typeobj @@ -1217,7 +1217,7 @@ class Dumper(DumperBase): self.typesToReport[typeName] = typeobj return typeobj - #warn(" RESULT FOR 7.2: '%s': %s" % (typeName, typeobj)) + #DumperBase.warn(" RESULT FOR 7.2: '%s': %s" % (typeName, typeobj)) # This part should only trigger for # gdb 7.1 for types with namespace separators. @@ -1255,24 +1255,24 @@ class Dumper(DumperBase): return typeobj try: - #warn("LOOKING UP 1 '%s'" % ts) + #DumperBase.warn("LOOKING UP 1 '%s'" % ts) typeobj = gdb.lookup_type(ts) except RuntimeError as error: - #warn("LOOKING UP 2 '%s' ERROR %s" % (ts, error)) + #DumperBase.warn("LOOKING UP 2 '%s' ERROR %s" % (ts, error)) # See http://sourceware.org/bugzilla/show_bug.cgi?id=11912 exp = "(class '%s'*)0" % ts try: typeobj = self.parse_and_eval(exp).type.target() - #warn("LOOKING UP 3 '%s'" % typeobj) + #DumperBase.warn("LOOKING UP 3 '%s'" % typeobj) except: # Can throw 'RuntimeError: No type named class Foo.' pass except: - #warn("LOOKING UP '%s' FAILED" % ts) + #DumperBase.warn("LOOKING UP '%s' FAILED" % ts) pass if not typeobj is None: - #warn('CACHING: %s' % typeobj) + #DumperBase.warn('CACHING: %s' % typeobj) self.typeCache[typeName] = typeobj self.typesToReport[typeName] = typeobj diff --git a/share/qtcreator/debugger/lldbbridge.py b/share/qtcreator/debugger/lldbbridge.py index 7d84bccdae8..9b4e54c195f 100644 --- a/share/qtcreator/debugger/lldbbridge.py +++ b/share/qtcreator/debugger/lldbbridge.py @@ -31,6 +31,8 @@ import sys import threading import time import lldb +import utils +from utils import DebuggerStartMode, BreakpointType, TypeCode from contextlib import contextmanager @@ -154,23 +156,23 @@ class Dumper(DumperBase): targetType = self.fromNativeType(nativeTargetType) val = self.createReferenceValue(nativeValue.GetValueAsUnsigned(), targetType) val.laddress = nativeValue.AddressOf().GetValueAsUnsigned() - #warn('CREATED REF: %s' % val) + #DumperBase.warn('CREATED REF: %s' % val) elif code == lldb.eTypeClassPointer: nativeTargetType = nativeType.GetPointeeType() if not nativeTargetType.IsPointerType(): nativeTargetType = nativeTargetType.GetUnqualifiedType() targetType = self.fromNativeType(nativeTargetType) val = self.createPointerValue(nativeValue.GetValueAsUnsigned(), targetType) - #warn('CREATED PTR 1: %s' % val) + #DumperBase.warn('CREATED PTR 1: %s' % val) val.laddress = nativeValue.AddressOf().GetValueAsUnsigned() - #warn('CREATED PTR 2: %s' % val) + #DumperBase.warn('CREATED PTR 2: %s' % val) elif code == lldb.eTypeClassTypedef: nativeTargetType = nativeType.GetUnqualifiedType() if hasattr(nativeTargetType, 'GetCanonicalType'): nativeTargetType = nativeTargetType.GetCanonicalType() val = self.fromNativeValue(nativeValue.Cast(nativeTargetType)) val.type = self.fromNativeType(nativeType) - #warn('CREATED TYPEDEF: %s' % val) + #DumperBase.warn('CREATED TYPEDEF: %s' % val) else: val = self.Value(self) address = nativeValue.GetLoadAddress() @@ -233,7 +235,7 @@ class Dumper(DumperBase): return align def listMembers(self, value, nativeType): - #warn("ADDR: 0x%x" % self.fakeAddress) + #DumperBase.warn("ADDR: 0x%x" % self.fakeAddress) fakeAddress = self.fakeAddress if value.laddress is None else value.laddress sbaddr = lldb.SBAddress(fakeAddress, self.target) fakeValue = self.target.CreateValueFromAddress('x', sbaddr, nativeType) @@ -359,8 +361,8 @@ class Dumper(DumperBase): # // Define a mask that can be used for any type when finding types # eTypeClassAny = (0xffffffffu) - #warn('CURRENT: %s' % self.typeData.keys()) - #warn('FROM NATIVE TYPE: %s' % nativeType.GetName()) + #DumperBase.warn('CURRENT: %s' % self.typeData.keys()) + #DumperBase.warn('FROM NATIVE TYPE: %s' % nativeType.GetName()) if code == lldb.eTypeClassInvalid: return None @@ -368,23 +370,23 @@ class Dumper(DumperBase): nativeType = nativeType.GetUnqualifiedType() if code == lldb.eTypeClassPointer: - #warn('PTR') + #DumperBase.warn('PTR') nativeTargetType = nativeType.GetPointeeType() if not nativeTargetType.IsPointerType(): nativeTargetType = nativeTargetType.GetUnqualifiedType() - #warn('PTR: %s' % nativeTargetType.name) + #DumperBase.warn('PTR: %s' % nativeTargetType.name) return self.createPointerType(self.fromNativeType(nativeTargetType)) if code == lldb.eTypeClassReference: - #warn('REF') + #DumperBase.warn('REF') nativeTargetType = nativeType.GetDereferencedType() if not nativeTargetType.IsPointerType(): nativeTargetType = nativeTargetType.GetUnqualifiedType() - #warn('REF: %s' % nativeTargetType.name) + #DumperBase.warn('REF: %s' % nativeTargetType.name) return self.createReferenceType(self.fromNativeType(nativeTargetType)) if code == lldb.eTypeClassTypedef: - #warn('TYPEDEF') + #DumperBase.warn('TYPEDEF') nativeTargetType = nativeType.GetUnqualifiedType() if hasattr(nativeTargetType, 'GetCanonicalType'): nativeTargetType = nativeTargetType.GetCanonicalType() @@ -395,12 +397,12 @@ class Dumper(DumperBase): typeName = self.typeName(nativeType) if code in (lldb.eTypeClassArray, lldb.eTypeClassVector): - #warn('ARRAY: %s' % nativeType.GetName()) + #DumperBase.warn('ARRAY: %s' % nativeType.GetName()) if hasattr(nativeType, 'GetArrayElementType'): # New in 3.8(?) / 350.x nativeTargetType = nativeType.GetArrayElementType() if not nativeTargetType.IsValid(): if hasattr(nativeType, 'GetVectorElementType'): # New in 3.8(?) / 350.x - #warn('BAD: %s ' % nativeTargetType.get_fields_array()) + #DumperBase.warn('BAD: %s ' % nativeTargetType.get_fields_array()) nativeTargetType = nativeType.GetVectorElementType() count = nativeType.GetByteSize() // nativeTargetType.GetByteSize() targetTypeName = nativeTargetType.GetName() @@ -408,7 +410,7 @@ class Dumper(DumperBase): typeName = nativeType.GetName() pos1 = typeName.rfind('[') targetTypeName = typeName[0:pos1].strip() - #warn("TARGET TYPENAME: %s" % targetTypeName) + #DumperBase.warn("TARGET TYPENAME: %s" % targetTypeName) targetType = self.fromNativeType(nativeTargetType) tdata = targetType.typeData().copy() tdata.name = targetTypeName @@ -431,33 +433,33 @@ class Dumper(DumperBase): tdata.name = typeName tdata.lbitsize = nativeType.GetByteSize() * 8 if code == lldb.eTypeClassBuiltin: - if isFloatingPointTypeName(typeName): - tdata.code = TypeCodeFloat - elif isIntegralTypeName(typeName): - tdata.code = TypeCodeIntegral + if utils.isFloatingPointTypeName(typeName): + tdata.code = TypeCode.TypeCodeFloat + elif utils.isIntegralTypeName(typeName): + tdata.code = TypeCode.TypeCodeIntegral elif typeName in ('__int128', 'unsigned __int128'): - tdata.code = TypeCodeIntegral + tdata.code = TypeCode.TypeCodeIntegral elif typeName == 'void': - tdata.code = TypeCodeVoid + tdata.code = TypeCode.TypeCodeVoid else: - warn('UNKNOWN TYPE KEY: %s: %s' % (typeName, code)) + self.warn('UNKNOWN TYPE KEY: %s: %s' % (typeName, code)) elif code == lldb.eTypeClassEnumeration: - tdata.code = TypeCodeEnum + tdata.code = TypeCode.TypeCodeEnum tdata.enumDisplay = lambda intval, addr, form : \ self.nativeTypeEnumDisplay(nativeType, intval, form) elif code in (lldb.eTypeClassComplexInteger, lldb.eTypeClassComplexFloat): - tdata.code = TypeCodeComplex + tdata.code = TypeCode.TypeCodeComplex elif code in (lldb.eTypeClassClass, lldb.eTypeClassStruct, lldb.eTypeClassUnion): - tdata.code = TypeCodeStruct + tdata.code = TypeCode.TypeCodeStruct tdata.lalignment = lambda : \ self.nativeStructAlignment(nativeType) tdata.lfields = lambda value : \ self.listMembers(value, nativeType) tdata.templateArguments = self.listTemplateParametersHelper(nativeType) elif code == lldb.eTypeClassFunction: - tdata.code = TypeCodeFunction + tdata.code = TypeCode.TypeCodeFunction elif code == lldb.eTypeClassMemberPointer: - tdata.code = TypeCodeMemberPointer + tdata.code = TypeCode.TypeCodeMemberPointer self.registerType(typeId, tdata) # Fix up fields and template args # warn('CREATE TYPE: %s' % typeId) @@ -491,12 +493,12 @@ class Dumper(DumperBase): targs.append(self.fromNativeType(innerType)) #elif kind == lldb.eTemplateArgumentKindIntegral: # innerType = nativeType.GetTemplateArgumentType(i).GetUnqualifiedType().GetCanonicalType() - # #warn('INNER TYP: %s' % innerType) + # #DumperBase.warn('INNER TYP: %s' % innerType) # basicType = innerType.GetBasicType() - # #warn('IBASIC TYP: %s' % basicType) + # #DumperBase.warn('IBASIC TYP: %s' % basicType) # inner = self.extractTemplateArgument(nativeType.GetName(), i) # exp = '(%s)%s' % (innerType.GetName(), inner) - # #warn('EXP : %s' % exp) + # #DumperBase.warn('EXP : %s' % exp) # val = self.nativeParseAndEvaluate('(%s)%s' % (innerType.GetName(), inner)) # # Clang writes 'int' and '0xfffffff' into the debug info # # LLDB manages to read a value of 0xfffffff... @@ -504,12 +506,12 @@ class Dumper(DumperBase): # value = val.GetValueAsUnsigned() # if value >= 0x8000000: # value -= 0x100000000 - # #warn('KIND: %s' % kind) + # #DumperBase.warn('KIND: %s' % kind) # targs.append(value) else: - #warn('UNHANDLED TEMPLATE TYPE : %s' % kind) + #DumperBase.warn('UNHANDLED TEMPLATE TYPE : %s' % kind) targs.append(stringArgs[i]) # Best we can do. - #warn('TARGS: %s %s' % (nativeType.GetName(), [str(x) for x in targs])) + #DumperBase.warn('TARGS: %s %s' % (nativeType.GetName(), [str(x) for x in targs])) return targs def typeName(self, nativeType): @@ -529,7 +531,7 @@ class Dumper(DumperBase): return name fields = nativeType.get_fields_array() typeId = c + ''.join(['{%s:%s}' % (f.name, self.nativeTypeId(f.GetType())) for f in fields]) - #warn('NATIVE TYPE ID FOR %s IS %s' % (name, typeId)) + #DumperBase.warn('NATIVE TYPE ID FOR %s IS %s' % (name, typeId)) return typeId def nativeTypeEnumDisplay(self, nativeType, intval, form): @@ -614,12 +616,12 @@ class Dumper(DumperBase): def callHelper(self, rettype, value, func, args): # args is a tuple. arg = ','.join(args) - #warn('PRECALL: %s -> %s(%s)' % (value.address(), func, arg)) + #DumperBase.warn('PRECALL: %s -> %s(%s)' % (value.address(), func, arg)) typename = value.type.name exp = '((%s*)0x%x)->%s(%s)' % (typename, value.address(), func, arg) - #warn('CALL: %s' % exp) + #DumperBase.warn('CALL: %s' % exp) result = self.currentContextValue.CreateValueFromExpression('', exp) - #warn(' -> %s' % result) + #DumperBase.warn(' -> %s' % result) return self.fromNativeValue(result) def pokeValue(self, typeName, *args): @@ -627,9 +629,9 @@ class Dumper(DumperBase): frame = thread.GetFrameAtIndex(0) inner = ','.join(args) value = frame.EvaluateExpression(typeName + '{' + inner + '}') - #self.warn(' TYPE: %s' % value.type) - #self.warn(' ADDR: 0x%x' % value.address) - #self.warn(' VALUE: %s' % value) + #DumperBase.warn(' TYPE: %s' % value.type) + #DumperBase.warn(' ADDR: 0x%x' % value.address) + #DumperBase.warn(' VALUE: %s' % value) return value def nativeParseAndEvaluate(self, exp): @@ -640,10 +642,10 @@ class Dumper(DumperBase): #val = self.target.EvaluateExpression(exp, options) err = val.GetError() if err.Fail(): - #warn('FAILING TO EVAL: %s' % exp) + #DumperBase.warn('FAILING TO EVAL: %s' % exp) return None - #warn('NO ERROR.') - #warn('EVAL: %s -> %s' % (exp, val.IsValid())) + #DumperBase.warn('NO ERROR.') + #DumperBase.warn('EVAL: %s -> %s' % (exp, val.IsValid())) return val def parseAndEvaluate(self, exp): @@ -749,14 +751,14 @@ class Dumper(DumperBase): return re.sub('^(struct|class|union|enum|typedef) ', '', name) def lookupNativeType(self, name): - #warn('LOOKUP TYPE NAME: %s' % name) + #DumperBase.warn('LOOKUP TYPE NAME: %s' % name) typeobj = self.typeCache.get(name) if not typeobj is None: - #warn('CACHED: %s' % name) + #DumperBase.warn('CACHED: %s' % name) return typeobj typeobj = self.target.FindFirstType(name) if typeobj.IsValid(): - #warn('VALID FIRST : %s' % typeobj) + #DumperBase.warn('VALID FIRST : %s' % typeobj) self.typeCache[name] = typeobj return typeobj @@ -773,16 +775,16 @@ class Dumper(DumperBase): for typeobj in typeobjlist: n = self.canonicalTypeName(self.removeTypePrefix(typeobj.GetDisplayTypeName())) if n == nonPrefixedName: - #warn('FOUND TYPE USING FindTypes : %s' % typeobj) + #DumperBase.warn('FOUND TYPE USING FindTypes : %s' % typeobj) self.typeCache[name] = typeobj return typeobj if name.endswith('*'): - #warn('RECURSE PTR') + #DumperBase.warn('RECURSE PTR') typeobj = self.lookupNativeType(name[:-1].strip()) if typeobj is not None: - #warn('RECURSE RESULT X: %s' % typeobj) + #DumperBase.warn('RECURSE RESULT X: %s' % typeobj) self.fromNativeType(typeobj.GetPointerType()) - #warn('RECURSE RESULT: %s' % typeobj.GetPointerType()) + #DumperBase.warn('RECURSE RESULT: %s' % typeobj.GetPointerType()) return typeobj.GetPointerType() #typeobj = self.target.FindFirstType(name[:-1].strip()) @@ -791,13 +793,13 @@ class Dumper(DumperBase): # return typeobj.GetPointerType() if name.endswith(' const'): - #warn('LOOKUP END CONST') + #DumperBase.warn('LOOKUP END CONST') typeobj = self.lookupNativeType(name[:-6]) if typeobj is not None: return typeobj if name.startswith('const '): - #warn('LOOKUP START CONST') + #DumperBase.warn('LOOKUP START CONST') typeobj = self.lookupNativeType(name[6:]) if typeobj is not None: return typeobj @@ -806,17 +808,17 @@ class Dumper(DumperBase): def lookupNativeTypeInAllModules(self, name): needle = self.canonicalTypeName(name) - #warn('NEEDLE: %s ' % needle) - warn('Searching for type %s across all target modules, this could be very slow' % name) + #DumperBase.warn('NEEDLE: %s ' % needle) + self.warn('Searching for type %s across all target modules, this could be very slow' % name) for i in xrange(self.target.GetNumModules()): module = self.target.GetModuleAtIndex(i) # SBModule.GetType is new somewhere after early 300.x # So this may fail. for t in module.GetTypes(): n = self.canonicalTypeName(t.GetName()) - #warn('N: %s' % n) + #DumperBase.warn('N: %s' % n) if n == needle: - #warn('FOUND TYPE DIRECT 2: %s ' % t) + #DumperBase.warn('FOUND TYPE DIRECT 2: %s ' % t) self.typeCache[name] = t return t if n == needle + '*': @@ -824,16 +826,16 @@ class Dumper(DumperBase): self.typeCache[name] = res x = self.fromNativeType(res) # Register under both names self.registerTypeAlias(x.typeId, name) - #warn('FOUND TYPE BY POINTER: %s ' % res.name) + #DumperBase.warn('FOUND TYPE BY POINTER: %s ' % res.name) return res if n == needle + '&': res = t.GetDereferencedType().GetUnqualifiedType() self.typeCache[name] = res x = self.fromNativeType(res) # Register under both names self.registerTypeAlias(x.typeId, name) - #warn('FOUND TYPE BY REFERENCE: %s ' % res.name) + #DumperBase.warn('FOUND TYPE BY REFERENCE: %s ' % res.name) return res - #warn('NOT FOUND: %s ' % needle) + #DumperBase.warn('NOT FOUND: %s ' % needle) return None def setupInferior(self, args): @@ -861,7 +863,7 @@ class Dumper(DumperBase): self.ignoreStops = 0 if platform.system() == 'Linux': - if self.startMode_ == AttachCore: + if self.startMode_ == DebuggerStartMode.AttachCore: pass else: if self.useTerminal_: @@ -911,7 +913,8 @@ class Dumper(DumperBase): self.reportState('enginerunandinferiorstopok') else: self.reportState('enginerunandinferiorrunok') - elif self.startMode_ == AttachToRemoteServer or self.startMode_ == AttachToRemoteProcess: + elif (self.startMode_ == DebuggerStartMode.AttachToRemoteServer + or self.startMode_ == DebuggerStartMode.AttachToRemoteProcess): self.process = self.target.ConnectRemote( self.debugger.GetListener(), self.remoteChannel_, None, error) @@ -923,7 +926,7 @@ class Dumper(DumperBase): # and later detects that it did stop after all, so it is be # better to mirror that and wait for the spontaneous stop. self.reportState('enginerunandinferiorrunok') - elif self.startMode_ == AttachCore: + elif self.startMode_ == DebuggerStartMode.AttachCore: coreFile = args.get('coreFile', ''); self.process = self.target.LoadCore(coreFile) if self.process.IsValid(): @@ -1124,7 +1127,7 @@ class Dumper(DumperBase): if size == 0: return bytes() error = lldb.SBError() - #warn("READ: %s %s" % (address, size)) + #DumperBase.warn("READ: %s %s" % (address, size)) res = self.process.ReadMemory(address, size, error) if res is None or len(res) != size: # Using code in e.g. readToFirstZero relies on exceptions. @@ -1307,12 +1310,12 @@ class Dumper(DumperBase): self.handleBreakpointEvent(event) return if not lldb.SBProcess.EventIsProcessEvent(event): - warn("UNEXPECTED event (%s)" % event.GetType()) + self.warn("UNEXPECTED event (%s)" % event.GetType()) return out = lldb.SBStream() event.GetDescription(out) - #warn("EVENT: %s" % event) + #DumperBase.warn("EVENT: %s" % event) eventType = event.GetType() msg = lldb.SBEvent.GetCStringFromEvent(event) flavor = event.GetDataFlavor() @@ -1430,7 +1433,7 @@ class Dumper(DumperBase): def insertBreakpoint(self, args): bpType = args['type'] - if bpType == BreakpointByFileAndLine: + if bpType == BreakpointType.BreakpointByFileAndLine: fileName = args['file'] if fileName.endswith('.js') or fileName.endswith('.qml'): self.insertInterpreterBreakpoint(args) @@ -1438,28 +1441,28 @@ class Dumper(DumperBase): extra = '' more = True - if bpType == BreakpointByFileAndLine: + if bpType == BreakpointType.BreakpointByFileAndLine: bp = self.target.BreakpointCreateByLocation( str(args['file']), int(args['line'])) - elif bpType == BreakpointByFunction: + elif bpType == BreakpointType.BreakpointByFunction: bp = self.target.BreakpointCreateByName(args['function']) - elif bpType == BreakpointByAddress: + elif bpType == BreakpointType.BreakpointByAddress: bp = self.target.BreakpointCreateByAddress(args['address']) - elif bpType == BreakpointAtMain: + elif bpType == BreakpointType.BreakpointAtMain: bp = self.createBreakpointAtMain() - elif bpType == BreakpointAtThrow: + elif bpType == BreakpointType.BreakpointAtThrow: bp = self.target.BreakpointCreateForException( lldb.eLanguageTypeC_plus_plus, False, True) - elif bpType == BreakpointAtCatch: + elif bpType == BreakpointType.BreakpointAtCatch: bp = self.target.BreakpointCreateForException( lldb.eLanguageTypeC_plus_plus, True, False) - elif bpType == WatchpointAtAddress: + elif bpType == BreakpointType.WatchpointAtAddress: error = lldb.SBError() # This might yield bp.IsValid() == False and # error.desc == 'process is not alive'. bp = self.target.WatchAddress(args['address'], 4, False, True, error) extra = self.describeError(error) - elif bpType == WatchpointAtExpression: + elif bpType == BreakpointType.WatchpointAtExpression: # FIXME: Top level-only for now. try: frame = self.currentFrame() @@ -1702,7 +1705,7 @@ class Dumper(DumperBase): else: base = args.get('address', 0) if int(base) == 0xffffffffffffffff: - warn('INVALID DISASSEMBLER BASE') + self.warn('INVALID DISASSEMBLER BASE') return addr = lldb.SBAddress(base, self.target) instructions = self.target.ReadInstructions(addr, 100) @@ -1736,7 +1739,7 @@ class Dumper(DumperBase): # With lldb-3.8 files like /data/dev/creator-3.6/tests/ # auto/debugger/qt_tst_dumpers_StdVector_bfNWZa/main.cpp # with non-existent directories appear. - warn('FILE: %s ERROR: %s' % (fileName, error)) + self.warn('FILE: %s ERROR: %s' % (fileName, error)) source = '' result += '{line="%s"' % lineNumber result += ',file="%s"' % fileName @@ -1836,7 +1839,7 @@ class Tester(Dumper): self.target = self.debugger.CreateTarget(binary, None, None, True, error) if error.GetType(): - warn('ERROR: %s' % error) + self.warn('ERROR: %s' % error) return s = threading.Thread(target=self.testLoop, args=(args,)) @@ -1856,14 +1859,14 @@ class Tester(Dumper): self.process = self.target.Launch(launchInfo, error) if error.GetType(): - warn('ERROR: %s' % error) + self.warn('ERROR: %s' % error) event = lldb.SBEvent() listener = self.debugger.GetListener() while True: state = self.process.GetState() if listener.WaitForEvent(100, event): - #warn('EVENT: %s' % event) + #DumperBase.warn('EVENT: %s' % event) state = lldb.SBProcess.GetStateFromEvent(event) if state == lldb.eStateExited: # 10 break @@ -1872,7 +1875,7 @@ class Tester(Dumper): for i in xrange(0, self.process.GetNumThreads()): thread = self.process.GetThreadAtIndex(i) reason = thread.GetStopReason() - #warn('THREAD: %s REASON: %s' % (thread, reason)) + #DumperBase.warn('THREAD: %s REASON: %s' % (thread, reason)) if (reason == lldb.eStopReasonBreakpoint or reason == lldb.eStopReasonException or reason == lldb.eStopReasonSignal): @@ -1894,8 +1897,8 @@ class Tester(Dumper): break else: - warn('TIMEOUT') - warn('Cannot determined stopped thread') + d.warn('TIMEOUT') + d.warn('Cannot determined stopped thread') lldb.SBDebugger.Destroy(self.debugger) @@ -1981,7 +1984,7 @@ class SummaryDumper(Dumper, LogMixin): return # Don't mess up lldb output def lookupNativeTypeInAllModules(self, name): - warn('Failed to resolve type %s' % name) + d.warn('Failed to resolve type %s' % name) return None def dump_summary(self, valobj, expanded = False): diff --git a/share/qtcreator/debugger/misctypes.py b/share/qtcreator/debugger/misctypes.py index 72e42e45101..a05c5f52940 100644 --- a/share/qtcreator/debugger/misctypes.py +++ b/share/qtcreator/debugger/misctypes.py @@ -24,6 +24,7 @@ ############################################################################ from dumper import * +from utils import TypeCode import re ####################################################################### @@ -100,7 +101,7 @@ def qdump____m512i(d, value): ####################################################################### def qform__std__array(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__gsl__span(d, value): size, pointer = value.split('pp') @@ -186,7 +187,7 @@ def qdump__NimStringDesc(d, value): def qdump__NimGenericSequence__(d, value, regex = '^TY[\d]+$'): code = value.type.stripTypedefs().code - if code == TypeCodeStruct: + if code == TypeCode.TypeCodeStruct: size, reserved = d.split('pp', value) data = value.address() + 2 * d.ptrSize() typeobj = value['data'].type.dereference() diff --git a/share/qtcreator/debugger/opencvtypes.py b/share/qtcreator/debugger/opencvtypes.py index 2e58637b383..2cbbc0cf57e 100644 --- a/share/qtcreator/debugger/opencvtypes.py +++ b/share/qtcreator/debugger/opencvtypes.py @@ -24,13 +24,14 @@ ############################################################################ from dumper import * +from utils import TypeCode def qdump__cv__Size_(d, value): d.putValue('(%s, %s)' % (value[0].display(), value[1].display())) d.putPlainChildren(value) def qform__cv__Mat(): - return [SeparateFormat] + return [DisplayFormat.SeparateFormat] def qdump__cv__Mat(d, value): (flag, dims, rows, cols, data, refcount, datastart, dataend, @@ -43,7 +44,7 @@ def qdump__cv__Mat(d, value): d.putPlainChildren(value) return - if d.currentItemFormat() == SeparateFormat: + if d.currentItemFormat() == DisplayFormat.SeparateFormat: rs = steps[0] * innerSize cs = cols * innerSize dform = 'arraydata:separate:int:%d::2:%d:%d' % (innerSize, cols, rows) @@ -53,7 +54,7 @@ def qdump__cv__Mat(d, value): d.putValue('(%s x %s)' % (rows, cols)) if d.isExpanded(): with Children(d): - innerType = d.createType(TypeCodeIntegral, innerSize) + innerType = d.createType(TypeCode.TypeCodeIntegral, innerSize) for i in range(rows): for j in range(cols): with SubItem(d, None): diff --git a/share/qtcreator/debugger/pdbbridge.py b/share/qtcreator/debugger/pdbbridge.py index 4f3a0fcd3bf..4c77d41ce5b 100644 --- a/share/qtcreator/debugger/pdbbridge.py +++ b/share/qtcreator/debugger/pdbbridge.py @@ -1552,10 +1552,10 @@ class QtcInternalDumper: self.put('name="%s",' % name) def isExpanded(self, iname): - # self.warn('IS EXPANDED: %s in %s' % (iname, self.expandedINames)) + # DumperBase.warn('IS EXPANDED: %s in %s' % (iname, self.expandedINames)) if iname.startswith('None'): raise "Illegal iname '%s'" % iname - # self.warn(' --> %s' % (iname in self.expandedINames)) + # DumperBase.warn(' --> %s' % (iname in self.expandedINames)) return iname in self.expandedINames def isExpandedIName(self, iname): diff --git a/share/qtcreator/debugger/qttypes.py b/share/qtcreator/debugger/qttypes.py index 65b0828cdb9..8f8fa10faa1 100644 --- a/share/qtcreator/debugger/qttypes.py +++ b/share/qtcreator/debugger/qttypes.py @@ -26,7 +26,7 @@ import platform import re from dumper import * - +from utils import DisplayFormat def qdump__QAtomicInt(d, value): d.putValue(value.integer()) @@ -44,8 +44,8 @@ def qdump__QAtomicPointer(d, value): def qform__QByteArray(): - return [Latin1StringFormat, SeparateLatin1StringFormat, - Utf8StringFormat, SeparateUtf8StringFormat ] + return [DisplayFormat.Latin1StringFormat, DisplayFormat.SeparateLatin1StringFormat, + DisplayFormat.Utf8StringFormat, DisplayFormat.SeparateUtf8StringFormat ] def qedit__QByteArray(d, value, data): d.call('void', value, 'resize', str(len(data))) @@ -58,14 +58,14 @@ def qdump__QByteArray(d, value): d.putNumChild(size) elided, p = d.encodeByteArrayHelper(d.extractPointer(value), d.displayStringLimit) displayFormat = d.currentItemFormat() - if displayFormat == AutomaticFormat or displayFormat == Latin1StringFormat: + if displayFormat == DisplayFormat.AutomaticFormat or displayFormat == DisplayFormat.Latin1StringFormat: d.putValue(p, 'latin1', elided=elided) - elif displayFormat == SeparateLatin1StringFormat: + elif displayFormat == DisplayFormat.SeparateLatin1StringFormat: d.putValue(p, 'latin1', elided=elided) d.putDisplay('latin1:separate', d.encodeByteArray(value, limit=100000)) - elif displayFormat == Utf8StringFormat: + elif displayFormat == DisplayFormat.Utf8StringFormat: d.putValue(p, 'utf8', elided=elided) - elif displayFormat == SeparateUtf8StringFormat: + elif displayFormat == DisplayFormat.SeparateUtf8StringFormat: d.putValue(p, 'utf8', elided=elided) d.putDisplay('utf8:separate', d.encodeByteArray(value, limit=100000)) if d.isExpanded(): @@ -103,11 +103,11 @@ def qdump__QChar(d, value): def qform_X_QAbstractItemModel(): - return [SimpleFormat, EnhancedFormat] + return [DisplayFormat.SimpleFormat, DisplayFormat.EnhancedFormat] def qdump_X_QAbstractItemModel(d, value): displayFormat = d.currentItemFormat() - if displayFormat == SimpleFormat: + if displayFormat == DisplayFormat.SimpleFormat: d.putPlainChildren(value) return #displayFormat == EnhancedFormat: @@ -137,11 +137,11 @@ def qdump_X_QAbstractItemModel(d, value): #gdb.execute('call free($ri)') def qform_X_QModelIndex(): - return [SimpleFormat, EnhancedFormat] + return [DisplayFormat.SimpleFormat, DisplayFormat.EnhancedFormat] def qdump_X_QModelIndex(d, value): displayFormat = d.currentItemFormat() - if displayFormat == SimpleFormat: + if displayFormat == DisplayFormat.SimpleFormat: d.putPlainChildren(value) return r = value['r'] @@ -306,12 +306,12 @@ def qdump__QDateTime(d, value): is32bit = d.ptrSize() == 4 if qtVersion >= 0x050200: tiVersion = d.qtTypeInfoVersion() - #warn('TI VERSION: %s' % tiVersion) + #DumperBase.warn('TI VERSION: %s' % tiVersion) if tiVersion is None: tiVersion = 4 if tiVersion > 10: status = d.extractByte(value) - #warn('STATUS: %s' % status) + #DumperBase.warn('STATUS: %s' % status) if status & 0x01: # Short data msecs = d.extractUInt64(value) >> 8 @@ -757,7 +757,7 @@ def qdump__QFixed(d, value): def qform__QFiniteStack(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__QFiniteStack(d, value): array, alloc, size = value.split('pii') @@ -775,7 +775,7 @@ def qdump__QFlags(d, value): def qform__QHash(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__QHash(d, value): qdumpHelper_QHash(d, value, value.type[0], value.type[1]) @@ -835,7 +835,7 @@ def qdumpHelper_QHash(d, value, keyType, valueType): def qform__QHashNode(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__QHashNode(d, value): d.putPairItem(None, value) @@ -872,7 +872,7 @@ def qdump__QHostAddress(d, value): dd = d.extractPointer(value) qtVersion = d.qtVersion() tiVersion = d.qtTypeInfoVersion() - #warn('QT: %x, TI: %s' % (qtVersion, tiVersion)) + #DumperBase.warn('QT: %x, TI: %s' % (qtVersion, tiVersion)) mayNeedParse = True if tiVersion is not None: if tiVersion >= 16: @@ -942,7 +942,7 @@ def qdump__QIPv6Address(d, value): d.putArrayData(value.address(), 16, d.lookupType('unsigned char')) def qform__QList(): - return [DirectQListStorageFormat, IndirectQListStorageFormat] + return [DisplayFormat.DirectQListStorageFormat, DisplayFormat.IndirectQListStorageFormat] def qdump__QList(d, value): return qdumpHelper_QList(d, value, value.type[0]) @@ -972,9 +972,9 @@ def qdumpHelper_QList(d, value, innerType): # in the frontend. # So as first approximation only do the 'isLarge' check: displayFormat = d.currentItemFormat() - if displayFormat == DirectQListStorageFormat: + if displayFormat == DisplayFormat.DirectQListStorageFormat: isInternal = True - elif displayFormat == IndirectQListStorageFormat: + elif displayFormat == DisplayFormat.IndirectQListStorageFormat: isInternal = False else: isInternal = innerSize <= stepSize and innerType.isMovableType() @@ -995,7 +995,7 @@ def qdumpHelper_QList(d, value, innerType): d.putSubItem(i, x) def qform__QImage(): - return [SimpleFormat, SeparateFormat] + return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat] def qdump__QImage(d, value): if d.qtVersion() < 0x050000: @@ -1024,7 +1024,7 @@ def qdump__QImage(d, value): d.putType('void *') displayFormat = d.currentItemFormat() - if displayFormat == SeparateFormat: + if displayFormat == DisplayFormat.SeparateFormat: d.putDisplay('imagedata:separate', '%08x%08x%08x%08x' % (width, height, nbytes, iformat) + d.readMemory(bits, nbytes)) @@ -1167,7 +1167,7 @@ def qdumpHelper_Qt5_QMap(d, value, keyType, valueType): def qform__QMap(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__QMap(d, value): qdumpHelper_QMap(d, value, value.type[0], value.type[1]) @@ -1179,13 +1179,13 @@ def qdumpHelper_QMap(d, value, keyType, valueType): qdumpHelper_Qt5_QMap(d, value, keyType, valueType) def qform__QMultiMap(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__QMultiMap(d, value): qdump__QMap(d, value) def qform__QVariantMap(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__QVariantMap(d, value): qdumpHelper_QMap(d, value, d.createType('QString'), d.createType('QVariant')) @@ -1458,7 +1458,7 @@ def qdump__QSizePolicy(d, value): def qform__QStack(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__QStack(d, value): qdump__QVector(d, value) @@ -1492,14 +1492,14 @@ def qedit__QString(d, value, data): d.setValues(base, 'short', [ord(c) for c in data]) def qform__QString(): - return [SimpleFormat, SeparateFormat] + return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat] def qdump__QString(d, value): d.putStringValue(value) (data, size, alloc) = d.stringData(value) d.putNumChild(size) displayFormat = d.currentItemFormat() - if displayFormat == SeparateFormat: + if displayFormat == DisplayFormat.SeparateFormat: d.putDisplay('utf16:separate', d.encodeString(value, limit=100000)) if d.isExpanded(): d.putArrayData(data, size, d.createType('QChar')) @@ -1596,7 +1596,7 @@ def qdump__QTextDocument(d, value): def qform__QUrl(): - return [SimpleFormat, SeparateFormat] + return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat] def qdump__QUrl(d, value): privAddress = d.extractPointer(value) @@ -1637,7 +1637,7 @@ def qdump__QUrl(d, value): d.putValue(url, 'utf16') displayFormat = d.currentItemFormat() - if displayFormat == SeparateFormat: + if displayFormat == DisplayFormat.SeparateFormat: d.putDisplay('utf16:separate', url) d.putNumChild(1) @@ -1851,7 +1851,7 @@ def qdump__QVariant(d, value): d.putNumChild(0) return None - #warn('TYPE: %s' % variantType) + #DumperBase.warn('TYPE: %s' % variantType) if variantType <= 86: # Known Core or Gui type. @@ -1867,15 +1867,15 @@ def qdump__QVariant(d, value): #data = value['d']['data'] innerType = d.qtNamespace() + innert - #warn('SHARED: %s' % isShared) + #DumperBase.warn('SHARED: %s' % isShared) if isShared: base1 = d.extractPointer(value) - #warn('BASE 1: %s %s' % (base1, innert)) + #DumperBase.warn('BASE 1: %s %s' % (base1, innert)) base = d.extractPointer(base1) - #warn('SIZE 1: %s' % size) + #DumperBase.warn('SIZE 1: %s' % size) val = d.createValue(base, innerType) else: - #warn('DIRECT ITEM 1: %s' % innerType) + #DumperBase.warn('DIRECT ITEM 1: %s' % innerType) val = d.createValue(data, innerType) val.laddress = value.laddress @@ -1939,7 +1939,7 @@ def qedit__QVector(d, value, data): def qform__QVector(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__QVector(d, value): @@ -2053,17 +2053,17 @@ def qdump__QXmlStreamAttribute(d, value): ####################################################################### def extractQmlData(d, value): - #if value.type.code == TypeCodePointer: + #if value.type.code == TypeCode.TypeCodePointer: # value = value.dereference() base = value.split('p')[0] #mmdata = d.split('Q', base)[0] #PointerMask = 0xfffffffffffffffd #vtable = mmdata & PointerMask - #warn('QML DATA: %s' % value.stringify()) + #DumperBase.warn('QML DATA: %s' % value.stringify()) #data = value['data'] #return #data.cast(d.lookupType(value.type.name.replace('QV4::', 'QV4::Heap::'))) typeName = value.type.name.replace('QV4::', 'QV4::Heap::') - #warn('TYOE DATA: %s' % typeName) + #DumperBase.warn('TYOE DATA: %s' % typeName) return d.createValue(base, typeName) def qdump__QV4__Heap__Base(d, value): @@ -2236,7 +2236,7 @@ def QV4_valueForData(d, jsval): # (Dumper, QJSValue *jsval) -> QV4::Value * v = QV4_getValue(d, jsval) if v: return v - warn('Not implemented: VARIANT') + d.warn('Not implemented: VARIANT') return 0 def QV4_putObjectValue(d, objectPtr): @@ -2424,7 +2424,7 @@ def qdump_64__QV4__Value(d, value): d.putBetterType('%sQV4::Value (object)' % ns) #QV4_putObjectValue(d, d.extractPointer(value) + 2 * d.ptrSize()) arrayVTable = d.symbolAddress(ns + 'QV4::ArrayObject::static_vtbl') - #warn('ARRAY VTABLE: 0x%x' % arrayVTable) + #DumperBase.warn('ARRAY VTABLE: 0x%x' % arrayVTable) d.putNumChild(1) d.putItem(d.createValue(d.extractPointer(value) + 2 * d.ptrSize(), ns + 'QV4::Object')) return @@ -2630,7 +2630,7 @@ def qdump__QScriptValue(d, value): payload = x['asBits']['payload'] #isValid = int(x['asBits']['tag']) != -6 # Empty #isCell = int(x['asBits']['tag']) == -2 - #warn('IS CELL: %s ' % isCell) + #DumperBase.warn('IS CELL: %s ' % isCell) #isObject = False #className = 'UNKNOWN NAME' #if isCell: @@ -2648,7 +2648,7 @@ def qdump__QScriptValue(d, value): # type = cell['m_structure']['m_typeInfo']['m_type'] # isObject = int(type) == 7 # ObjectType; # className = 'UNKNOWN NAME' - #warn('IS OBJECT: %s ' % isObject) + #DumperBase.warn('IS OBJECT: %s ' % isObject) #inline bool JSCell::inherits(const ClassInfo* info) const #for (const ClassInfo* ci = classInfo(); ci; ci = ci->parentClass) { diff --git a/share/qtcreator/debugger/stdtypes.py b/share/qtcreator/debugger/stdtypes.py index 076a71c0095..3b8542707ae 100644 --- a/share/qtcreator/debugger/stdtypes.py +++ b/share/qtcreator/debugger/stdtypes.py @@ -23,10 +23,11 @@ # ############################################################################ +from utils import DisplayFormat from dumper import * def qform__std__array(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__std__array(d, value): size = value.type[1] @@ -36,7 +37,7 @@ def qdump__std__array(d, value): def qform__std____1__array(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__std____1__array(d, value): qdump__std__array(d, value) @@ -260,7 +261,7 @@ def qdump__std____1__list(d, value): d.putSubItem(i, val) def qform__std__map(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__std__map(d, value): if d.isQnxTarget() or d.isMsvcTarget(): @@ -334,7 +335,7 @@ def qdump__std____cxx1998__map(d, value): qdump__std__map(d, value) def qform__std__multimap(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__std__multimap(d, value): return qdump__std__map(d, value) @@ -537,7 +538,7 @@ def qdump__std____1__multiset(d, value): qdump__std____1__set(d, value) def qform__std____1__map(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__std____1__map(d, value): try: @@ -574,7 +575,7 @@ def qdump__std____1__map(d, value): d.putPairItem(i, pair, 'key', 'value') def qform__std____1__multimap(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__std____1__multimap(d, value): qdump__std____1__map(d, value) @@ -620,8 +621,8 @@ def qdump__std____1__stack(d, value): d.putBetterType(value.type) def qform__std__string(): - return [Latin1StringFormat, SeparateLatin1StringFormat, - Utf8StringFormat, SeparateUtf8StringFormat ] + return [DisplayFormat.Latin1StringFormat, DisplayFormat.SeparateLatin1StringFormat, + DisplayFormat.Utf8StringFormat, DisplayFormat.SeparateUtf8StringFormat ] def qdump__std__string(d, value): qdumpHelper_std__string(d, value, d.createType("char"), d.currentItemFormat()) @@ -760,10 +761,10 @@ def qdump__std__pair(d, value): d.putValue(value.value, value.encoding) def qform__std__unordered_map(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qform__std____debug__unordered_map(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__std__unordered_map(d, value): if d.isQnxTarget() or d.isMsvcTarget(): @@ -861,7 +862,7 @@ def qdump__std__unordered_set(d, value): p = d.extractPointer(p + offset) def qform__std____1__unordered_map(): - return mapForms() + return [DisplayFormat.CompactMapFormat] def qdump__std____1__unordered_map(d, value): (size, _) = value["__table_"]["__p2_"].split("pp") @@ -916,7 +917,7 @@ def qdump__std____debug__unordered_multiset(d, value): def qform__std__valarray(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__std__valarray(d, value): if d.isMsvcTarget(): @@ -928,7 +929,7 @@ def qdump__std__valarray(d, value): def qform__std____1__valarray(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__std____1__valarray(d, value): innerType = value.type[0] @@ -939,7 +940,7 @@ def qdump__std____1__valarray(d, value): def qform__std__vector(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qedit__std__vector(d, value, data): import gdb @@ -1036,13 +1037,13 @@ def qdumpHelper__std__vector__QNX(d, value): d.putPlotData(start, size, innerType) def qform__std____1__vector(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__std____1__vector(d, value): qdumpHelper__std__vector(d, value, True) def qform__std____debug__vector(): - return arrayForms() + return [DisplayFormat.ArrayPlotFormat] def qdump__std____debug__vector(d, value): qdump__std__vector(d, value) @@ -1088,7 +1089,7 @@ def qdump__string(d, value): qdump__std__string(d, value) def qform__std__wstring(): - return [SimpleFormat, SeparateFormat] + return [DisplayFormat.SimpleFormat, DisplayFormat.SeparateFormat] def qdump__std__wstring(d, value): qdumpHelper_std__string(d, value, d.createType('wchar_t'), d.currentItemFormat()) @@ -1131,7 +1132,7 @@ def qdump__std____1__basic_string(d, value): elif innerType == "wchar_t": qdump__std____1__wstring(d, value) else: - warn("UNKNOWN INNER TYPE %s" % innerType) + d.warn("UNKNOWN INNER TYPE %s" % innerType) def qdump__wstring(d, value): qdump__std__wstring(d, value) diff --git a/share/qtcreator/debugger/utils.py b/share/qtcreator/debugger/utils.py new file mode 100644 index 00000000000..f67b9311199 --- /dev/null +++ b/share/qtcreator/debugger/utils.py @@ -0,0 +1,130 @@ +############################################################################ +# +# Copyright (C) 2016 The Qt Company Ltd. +# Contact: https://www.qt.io/licensing/ +# +# This file is part of Qt Creator. +# +# Commercial License Usage +# Licensees holding valid commercial Qt licenses may use this file in +# accordance with the commercial license agreement provided with the +# Software or, alternatively, in accordance with the terms contained in +# a written agreement between you and The Qt Company. For licensing terms +# and conditions see https://www.qt.io/terms-conditions. For further +# information use the contact form at https://www.qt.io/contact-us. +# +# GNU General Public License Usage +# Alternatively, this file may be used under the terms of the GNU +# General Public License version 3 as published by the Free Software +# Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +# included in the packaging of this file. Please review the following +# information to ensure the GNU General Public License requirements will +# be met: https://www.gnu.org/licenses/gpl-3.0.html. +# +############################################################################ + +# Debugger start modes. Keep in sync with DebuggerStartMode in debuggerconstants.h + + +class DebuggerStartMode: + ( + NoStartMode, + StartInternal, + StartExternal, + AttachExternal, + AttachCrashedExternal, + AttachCore, + AttachToRemoteServer, + AttachToRemoteProcess, + StartRemoteProcess, + ) = range(0, 9) + + +# Known special formats. Keep in sync with DisplayFormat in debuggerprotocol.h +class DisplayFormat: + ( + AutomaticFormat, + RawFormat, + SimpleFormat, + EnhancedFormat, + SeparateFormat, + Latin1StringFormat, + SeparateLatin1StringFormat, + Utf8StringFormat, + SeparateUtf8StringFormat, + Local8BitStringFormat, + Utf16StringFormat, + Ucs4StringFormat, + Array10Format, + Array100Format, + Array1000Format, + Array10000Format, + ArrayPlotFormat, + CompactMapFormat, + DirectQListStorageFormat, + IndirectQListStorageFormat, + ) = range(0, 20) + + +# Breakpoints. Keep synchronized with BreakpointType in breakpoint.h +class BreakpointType: + ( + UnknownType, + BreakpointByFileAndLine, + BreakpointByFunction, + BreakpointByAddress, + BreakpointAtThrow, + BreakpointAtCatch, + BreakpointAtMain, + BreakpointAtFork, + BreakpointAtExec, + BreakpointAtSysCall, + WatchpointAtAddress, + WatchpointAtExpression, + BreakpointOnQmlSignalEmit, + BreakpointAtJavaScriptThrow, + ) = range(0, 14) + + +# Internal codes for types keep in sync with cdbextensions pytype.cpp +class TypeCode: + ( + TypeCodeTypedef, + TypeCodeStruct, + TypeCodeVoid, + TypeCodeIntegral, + TypeCodeFloat, + TypeCodeEnum, + TypeCodePointer, + TypeCodeArray, + TypeCodeComplex, + TypeCodeReference, + TypeCodeFunction, + TypeCodeMemberPointer, + TypeCodeFortranString, + TypeCodeUnresolvable, + TypeCodeBitfield, + TypeCodeRValueReference, + ) = range(0, 16) + + +def isIntegralTypeName(name): + return name in ( + "int", + "unsigned int", + "signed int", + "short", + "unsigned short", + "long", + "unsigned long", + "long long", + "unsigned long long", + "char", + "signed char", + "unsigned char", + "bool", + ) + + +def isFloatingPointTypeName(name): + return name in ("float", "double", "long double")