Debugger: Split qttypes.py

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

Change-Id: I3bce8dfe912c528f3a0d8d6670108f8d3272b4af
Reviewed-by: David Schulz <david.schulz@digia.com>

share/qtcreator/debugger/boosttypes.py

+############################################################################
+#
+# 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)
+
+

share/qtcreator/debugger/creatortypes.py

+############################################################################
+#
+# 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)
+
+

share/qtcreator/debugger/gdbbridge.py

@@ -23,6 +23,10 @@ def warn(message):
 
 from dumper import *
 from qttypes import *
+from stdtypes import *
+from misctypes import *
+from boosttypes import *
+
 
 #######################################################################
 #

share/qtcreator/debugger/lldbbridge.py

@@ -41,6 +41,9 @@ sys.path.insert(1, currentDir)
 
 from dumper import *
 from qttypes import *
+from stdtypes import *
+from misctypes import *
+from boosttypes import *
 
 
 

share/qtcreator/debugger/misctypes.py

+############################################################################
+#
+# 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)