Commit d6afbdd0 authored by hjk's avatar hjk Committed by David Schulz

Debugger: Split qttypes.py

... into qttypes, stdtypes, boosttypes, and misctypes.py

Change-Id: I3bce8dfe912c528f3a0d8d6670108f8d3272b4af
Reviewed-by: default avatarDavid Schulz <david.schulz@digia.com>
parent 6c0ef367
############################################################################
#
# Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
# Contact: http://www.qt-project.org/legal
#
# 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 Digia. For licensing terms and
# conditions see http://qt.digia.com/licensing. For further information
# use the contact form at http://qt.digia.com/contact-us.
#
# GNU Lesser General Public License Usage
# Alternatively, this file may be used under the terms of the GNU Lesser
# General Public License version 2.1 as published by the Free Software
# Foundation and appearing in the file LICENSE.LGPL included in the
# packaging of this file. Please review the following information to
# ensure the GNU Lesser General Public License version 2.1 requirements
# will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
#
# In addition, as a special exception, Digia gives you certain additional
# rights. These rights are described in the Digia Qt LGPL Exception
# version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
#
#############################################################################
from dumper import *
def qdump__boost__bimaps__bimap(d, value):
#leftType = d.templateArgument(value.type, 0)
#rightType = d.templateArgument(value.type, 1)
size = int(value["core"]["node_count"])
d.putItemCount(size)
d.putNumChild(size)
if d.isExpanded():
d.putPlainChildren(value)
def qdump__boost__optional(d, value):
if int(value["m_initialized"]) == 0:
d.putValue("<uninitialized>")
d.putNumChild(0)
else:
type = d.templateArgument(value.type, 0)
storage = value["m_storage"]
if d.isReferenceType(type):
d.putItem(storage.cast(type.target().pointer()).dereference())
else:
d.putItem(storage.cast(type))
d.putBetterType(value.type)
def qdump__boost__shared_ptr(d, value):
# s boost::shared_ptr<int>
# pn boost::detail::shared_count
# pi_ 0x0 boost::detail::sp_counted_base *
# px 0x0 int *
if d.isNull(value["pn"]["pi_"]):
d.putValue("(null)")
d.putNumChild(0)
return
if d.isNull(value["px"]):
d.putValue("(null)")
d.putNumChild(0)
return
countedbase = value["pn"]["pi_"].dereference()
weakcount = int(countedbase["weak_count_"])
usecount = int(countedbase["use_count_"])
d.check(weakcount >= 0)
d.check(weakcount <= int(usecount))
d.check(usecount <= 10*1000*1000)
val = value["px"].dereference()
if d.isSimpleType(val.type):
d.putNumChild(3)
d.putItem(val)
d.putBetterType(value.type)
else:
d.putEmptyValue()
d.putNumChild(3)
if d.isExpanded():
with Children(d, 3):
d.putSubItem("data", val)
d.putIntItem("weakcount", weakcount)
d.putIntItem("usecount", usecount)
def qdump__boost__gregorian__date(d, value):
d.putValue(int(value["days_"]), JulianDate)
d.putNumChild(0)
def qdump__boost__posix_time__ptime(d, item):
ms = int(item["time_"]["time_count_"]["value_"]) / 1000
d.putValue("%s/%s" % divmod(ms, 86400000), JulianDateAndMillisecondsSinceMidnight)
d.putNumChild(0)
def qdump__boost__posix_time__time_duration(d, item):
d.putValue(int(item["ticks_"]["value_"]) / 1000, MillisecondsSinceMidnight)
d.putNumChild(0)
############################################################################
#
# Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
# Contact: http://www.qt-project.org/legal
#
# 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 Digia. For licensing terms and
# conditions see http://qt.digia.com/licensing. For further information
# use the contact form at http://qt.digia.com/contact-us.
#
# GNU Lesser General Public License Usage
# Alternatively, this file may be used under the terms of the GNU Lesser
# General Public License version 2.1 as published by the Free Software
# Foundation and appearing in the file LICENSE.LGPL included in the
# packaging of this file. Please review the following information to
# ensure the GNU Lesser General Public License version 2.1 requirements
# will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
#
# In addition, as a special exception, Digia gives you certain additional
# rights. These rights are described in the Digia Qt LGPL Exception
# version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
#
#############################################################################
from dumper import *
def qdump__Core__Id(d, value):
try:
name = parseAndEvaluate("Core::nameForId(%d)" % value["m_id"])
d.putValue(encodeCharArray(name), Hex2EncodedLatin1)
d.putPlainChildren(value)
except:
d.putValue(value["m_id"])
d.putNumChild(0)
def qdump__Debugger__Internal__GdbMi(d, value):
str = d.encodeByteArray(value["m_name"]) + "3a20" \
+ d.encodeByteArray(value["m_data"])
d.putValue(str, Hex2EncodedLatin1)
d.putPlainChildren(value)
def qdump__Debugger__Internal__WatchData(d, value):
d.putByteArrayValue(value["iname"])
d.putPlainChildren(value)
def qdump__Debugger__Internal__WatchItem(d, value):
d.putByteArrayValue(value["iname"])
d.putPlainChildren(value)
def qdump__Debugger__Internal__BreakpointModelId(d, value):
d.putValue("%s.%s" % (value["m_majorPart"], value["m_minorPart"]))
d.putPlainChildren(value)
def qdump__CPlusPlus__ByteArrayRef(d, value):
d.putValue(encodeCharArray(value["m_start"], 100, value["m_length"]),
Hex2EncodedLatin1)
d.putPlainChildren(value)
def qdump__CPlusPlus__Identifier(d, value):
d.putValue(encodeCharArray(value["_chars"]), Hex2EncodedLatin1)
d.putPlainChildren(value)
def qdump__CPlusPlus__IntegerType(d, value):
d.putValue(value["_kind"])
d.putPlainChildren(value)
def qdump__CPlusPlus__NamedType(d, value):
literal = downcast(value["_name"])
d.putValue(encodeCharArray(literal["_chars"]), Hex2EncodedLatin1)
d.putPlainChildren(value)
def qdump__CPlusPlus__TemplateNameId(d, value):
s = encodeCharArray(value["_identifier"]["_chars"])
d.putValue(s + "3c2e2e2e3e", Hex2EncodedLatin1)
d.putPlainChildren(value)
def qdump__CPlusPlus__Literal(d, value):
d.putValue(encodeCharArray(value["_chars"]), Hex2EncodedLatin1)
d.putPlainChildren(value)
def qdump__CPlusPlus__StringLiteral(d, value):
d.putValue(encodeCharArray(value["_chars"]), Hex2EncodedLatin1)
d.putPlainChildren(value)
def qdump__CPlusPlus__Internal__Value(d, value):
d.putValue(value["l"])
d.putPlainChildren(value)
def qdump__Utils__FileName(d, value):
d.putStringValue(value)
d.putPlainChildren(value)
def qdump__Utils__ElfSection(d, value):
d.putByteArrayValue(value["name"])
d.putPlainChildren(value)
def qdump__CPlusPlus__Token(d, value):
k = int(value["f"]["kind"])
if int(k) == 6:
d.putValue("T_IDENTIFIER. offset: %d, len: %d"
% (value["offset"], value["f"]["length"]))
elif int(k) == 7:
d.putValue("T_NUMERIC_LITERAL. offset: %d, value: %d"
% (value["offset"], value["f"]["length"]))
elif int(k) == 60:
d.putValue("T_RPAREN")
else:
d.putValue("Type: %s" % k)
d.putPlainChildren(value)
def qdump__CPlusPlus__Internal__PPToken(d, value):
k = value["f"]["kind"];
data, size, alloc = d.byteArrayData(value["m_src"])
length = int(value["f"]["length"])
offset = int(value["offset"])
#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)),
Hex2EncodedLatin1)
d.putPlainChildren(value)
......@@ -23,6 +23,10 @@ def warn(message):
from dumper import *
from qttypes import *
from stdtypes import *
from misctypes import *
from boosttypes import *
#######################################################################
#
......
......@@ -41,6 +41,9 @@ sys.path.insert(1, currentDir)
from dumper import *
from qttypes import *
from stdtypes import *
from misctypes import *
from boosttypes import *
......
############################################################################
#
# Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
# Contact: http://www.qt-project.org/legal
#
# 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 Digia. For licensing terms and
# conditions see http://qt.digia.com/licensing. For further information
# use the contact form at http://qt.digia.com/contact-us.
#
# GNU Lesser General Public License Usage
# Alternatively, this file may be used under the terms of the GNU Lesser
# General Public License version 2.1 as published by the Free Software
# Foundation and appearing in the file LICENSE.LGPL included in the
# packaging of this file. Please review the following information to
# ensure the GNU Lesser General Public License version 2.1 requirements
# will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
#
# In addition, as a special exception, Digia gives you certain additional
# rights. These rights are described in the Digia Qt LGPL Exception
# version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
#
#############################################################################
from dumper import *
#######################################################################
#
# SSE
#
#######################################################################
def qform____m128():
return "As Floats,As Doubles"
def qdump____m128(d, value):
d.putEmptyValue()
d.putNumChild(1)
if d.isExpanded():
format = d.currentItemFormat()
if format == 2: # As Double
d.putArrayData(d.lookupType("double"), value.address, 2)
else: # Default, As float
d.putArrayData(d.lookupType("float"), value.address, 4)
#######################################################################
#
# Eigen
#
#######################################################################
#def qform__Eigen__Matrix():
# return "Transposed"
def qdump__Eigen__Matrix(d, value):
innerType = d.templateArgument(value.type, 0)
storage = value["m_storage"]
options = d.numericTemplateArgument(value.type, 3)
rowMajor = (int(options) & 0x1)
argRow = d.numericTemplateArgument(value.type, 1)
argCol = d.numericTemplateArgument(value.type, 2)
nrows = value["m_storage"]["m_rows"] if argRow == -1 else int(argRow)
ncols = value["m_storage"]["m_cols"] if argCol == -1 else int(argCol)
p = storage["m_data"]
if d.isStructType(p.type): # Static
p = p["array"].cast(innerType.pointer())
d.putValue("(%s x %s), %s" % (nrows, ncols, ["ColumnMajor", "RowMajor"][rowMajor]))
d.putField("keeporder", "1")
d.putNumChild(nrows * ncols)
limit = 10000
nncols = min(ncols, limit)
nnrows = min(nrows, limit * limit / nncols)
if d.isExpanded():
#format = d.currentItemFormat() # format == 1 is "Transposed"
with Children(d, nrows * ncols, childType=innerType):
if ncols == 1 or nrows == 1:
for i in range(0, min(nrows * ncols, 10000)):
d.putSubItem(i, (p + i).dereference())
elif rowMajor == 1:
s = 0
for i in range(0, nnrows):
for j in range(0, nncols):
v = (p + i * ncols + j).dereference()
d.putNamedSubItem(s, v, "[%d,%d]" % (i, j))
s = s + 1
else:
s = 0
for j in range(0, nncols):
for i in range(0, nnrows):
v = (p + i + j * nrows).dereference()
d.putNamedSubItem(s, v, "[%d,%d]" % (i, j))
s = s + 1
#######################################################################
#
# D
#
#######################################################################
def cleanDType(type):
return d.stripClassTag(str(type)).replace("uns long long", "string")
def qdump_Array(d, value):
n = value["length"]
p = value["ptr"]
t = cleanDType(value.type)[7:]
d.putType("%s[%d]" % (t, n))
if t == "char":
d.putValue(encodeCharArray(p, 100), Hex2EncodedLocal8Bit)
d.putNumChild(0)
else:
d.putEmptyValue()
d.putNumChild(n)
innerType = p.type
if d.isExpanded():
with Children(d, n, childType=innerType):
for i in range(0, n):
d.putSubItem(i, p.dereference())
p = p + 1
def qdump_AArray(d, value):
#n = value["length"]
# This ends up as _AArray_<key>_<value> with a single .ptr
# member of type void *. Not much that can be done here.
p = value["ptr"]
t = cleanDType(value.type)[8:]
d.putType("%s]" % t.replace("_", "["))
d.putEmptyValue()
d.putNumChild(1)
if d.isExpanded():
with Children(d, 1):
d.putSubItem("ptr", p)
#######################################################################
#
# Display Test
#
#######################################################################
if False:
# FIXME: Make that work
def qdump__Color(d, value):
v = value
d.putValue("(%s, %s, %s; %s)" % (v["r"], v["g"], v["b"], v["a"]))
d.putPlainChildren(value)
def qdump__Color_(d, value):
v = value
d.putValue("(%s, %s, %s; %s)" % (v["r"], v["g"], v["b"], v["a"]))
if d.isExpanded():
with Children(d):
with SubItem(d, "0"):
d.putItem(v["r"])
with SubItem(d, "1"):
d.putItem(v["g"])
with SubItem(d, "2"):
d.putItem(v["b"])
with SubItem(d, "3"):
d.putItem(v["a"])
if False:
def qform__basic__Function():
return "Normal,Displayed"
def qdump__basic__Function(d, value):
min = value["min"]
max = value["max"]
data, size, alloc = d.byteArrayData(value["var"])
var = extractCString(data, 0)
data, size, alloc = d.byteArrayData(value["f"])
f = extractCString(data, 0)
d.putValue("%s, %s=%f..%f" % (f, var, min, max))
d.putNumChild(0)
format = d.currentItemFormat()
if format == 1:
d.putDisplay(StopDisplay)
elif format == 2:
input = "plot [%s=%f:%f] %s" % (var, min, max, f)
d.putDisplay(DisplayProcess, input, "gnuplot")
if False:
def qdump__tree_entry(d, value):
d.putValue("len: %s, offset: %s, type: %s" %
(value["blocklength"], value["offset"], value["type"]))
d.putNumChild(0)
def qdump__tree(d, value):
count = value["count"]
entries = value["entries"]
base = value["base"].cast(d.charPtrType())
d.putItemCount(count)
d.putNumChild(count)
if d.isExpanded():
with Children(d):
with SubItem(d, "tree"):
d.putEmptyValue()
d.putNoType()
d.putNumChild(1)
if d.isExpanded():
with Children(d):
for i in xrange(count):
d.putSubItem(Item(entries[i], iname))
with SubItem(d, "data"):
d.putEmptyValue()
d.putNoType()
d.putNumChild(1)
if d.isExpanded():
with Children(d):
for i in xrange(count):
with SubItem(d, i):
entry = entries[i]
mpitype = str(entry["type"])
d.putType(mpitype)
length = int(entry["blocklength"])
offset = int(entry["offset"])
d.putValue("%s items at %s" % (length, offset))
if mpitype == "MPI_INT":
innerType = "int"
elif mpitype == "MPI_CHAR":
innerType = "char"
elif mpitype == "MPI_DOUBLE":
innerType = "double"
else:
length = 0
d.putNumChild(length)
if d.isExpanded():
with Children(d):
t = d.lookupType(innerType).pointer()
p = (base + offset).cast(t)
for j in range(length):
d.putSubItem(j, p.dereference())
#struct KRBase
#{
# enum Type { TYPE_A, TYPE_B } type;
# KRBase(Type _type) : type(_type) {}
#};
#
#struct KRA : KRBase { int x; int y; KRA():KRBase(TYPE_A),x(1),y(32) {} };
#struct KRB : KRBase { KRB():KRBase(TYPE_B) {} };
#
#void testKR()
#{
# KRBase *ptr1 = new KRA;
# KRBase *ptr2 = new KRB;
# ptr2 = new KRB;
#}
def qdump__KRBase(d, value):
if getattr(value, "__nested__", None) is None:
base = ["KRA", "KRB"][int(value["type"])]
nest = value.cast(d.lookupType(base))
nest.__nested__ = True
warn("NEST %s " % dir(nest))
d.putItem(nest)
else:
d.putName("type")
d.putValue(value["type"])
d.putNoType()
if False:
def qdump__bug5106__A5106(d, value):
d.putName("a")
d.putValue("This is the value: %s" % value["m_a"])
d.putNoType()
d.putNumChild(0)
if False:
def qdump__bug6933__Base(d, value):
d.putValue("foo")
d.putPlainChildren(value)
if False:
def qdump__gdb13393__Base(d, value):
d.putValue("Base (%s)" % value["a"])
d.putType(value.type)
d.putPlainChildren(value)
def qdump__gdb13393__Derived(d, value):
d.putValue("Derived (%s, %s)" % (value["a"], value["b"]))
d.putType(value.type)
d.putPlainChildren(value)
def qdump__KDSoapValue1(d, value):
inner = value["d"]["d"].dereference()
d.putStringValue(inner["m_name"])
if d.isExpanded():
with Children(d):
d.putFields(inner)
def qdump__KDSoapValue(d, value):
p = (value.cast(lookupType("char*")) + 4).dereference().cast(lookupType("QString"))
d.putStringValue(p)
if d.isExpanded():
with Children(d):
data = value["d"]["d"].dereference()
d.putFields(data)
This diff is collapsed.
This diff is collapsed.
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment