gdbmacros.cpp

qconsole2 qt寫的一個console元件

static void qDumpQObjectSignal(QDumper &d)
{
    unsigned signalNumber = d.extraInt[0];

    P(d, "addr", "<synthetic>");
    P(d, "numchild", "1");
    P(d, "type", NS"QObjectSignal");

#if QT_VERSION >= 0x040400
    if (d.dumpChildren) {
        const QObject *ob = reinterpret_cast<const QObject *>(d.data);
        d << ",children=[";
        const QObjectPrivate::ConnectionList &connList = qConnectionList(ob, signalNumber);
        for (int i = 0; i != connList.size(); ++i) {
            const QObjectPrivate::Connection &conn = connList.at(i);
            d.beginHash();
                P(d, "name", "[" << i << "] receiver");
                qDumpInnerValueHelper(d, NS"QObject *", conn.receiver);
            d.endHash();
            d.beginHash();
                P(d, "name", "[" << i << "] slot");
                P(d, "type", "");
                if (conn.receiver) 
                    P(d, "value", conn.receiver->metaObject()->method(conn.method).signature());
                else
                    P(d, "value", "<invalid receiver>");
                P(d, "numchild", "0");
            d.endHash();
            d.beginHash();
                P(d, "name", "[" << i << "] type");
                P(d, "type", "");
                P(d, "value", "<" << qConnectionTypes[conn.method] << " connection>");
                P(d, "numchild", "0");
            d.endHash();
        }
        d << "]";
        P(d, "numchild", connList.size());
    }
#endif
    d.disarm();
}

static void qDumpQObjectSignalList(QDumper &d)
{
    const QObject *ob = reinterpret_cast<const QObject *>(d.data);
    const QMetaObject *mo = ob->metaObject();
    int count = 0;
    for (int i = mo->methodCount(); --i >= 0; )
        count += (mo->method(i).methodType() == QMetaMethod::Signal);
    P(d, "addr", d.data);
    P(d, "numchild", count);
#if QT_VERSION >= 0x040400
    if (d.dumpChildren) {
        d << ",children=[";
        for (int i = 0; i != mo->methodCount(); ++i) {
            const QMetaMethod & method = mo->method(i);
            if (method.methodType() == QMetaMethod::Signal) {
                int k = mo->indexOfSignal(method.signature());
                const QObjectPrivate::ConnectionList &connList = qConnectionList(ob, k);
                d.beginHash();
                P(d, "name", "[" << k << "]");
                P(d, "value", method.signature());
                P(d, "numchild", connList.size());
                //P(d, "numchild", "1");
                P(d, "exp", "*(class '"NS"QObject'*)" << d.data);
                P(d, "type", NS"QObjectSignal");
                d.endHash();
            }
        }
        d << "]";
    }
#endif
    d.disarm();
}

static void qDumpQObjectSlot(QDumper &d)
{
    int slotNumber = d.extraInt[0];

    P(d, "addr", d.data);
    P(d, "numchild", "1");
    P(d, "type", NS"QObjectSlot");

#if QT_VERSION >= 0x040400
    if (d.dumpChildren) {
        d << ",children=[";
        int numchild = 0;
        const QObject *ob = reinterpret_cast<const QObject *>(d.data);
        const QObjectPrivate *p = reinterpret_cast<const QObjectPrivate *>(dfunc(ob));
        for (int s = 0; s != p->senders.size(); ++s) {
            const QObjectPrivate::Sender &sender = p->senders.at(s);
            const QObjectPrivate::ConnectionList &connList
                = qConnectionList(sender.sender, sender.signal);
            for (int i = 0; i != connList.size(); ++i) {
                const QObjectPrivate::Connection &conn = connList.at(i);
                if (conn.receiver == ob && conn.method == slotNumber) {
                    ++numchild;
                    const QMetaMethod & method =
                        sender.sender->metaObject()->method(sender.signal);
                    d.beginHash();
                        P(d, "name", "[" << s << "] sender");
                        qDumpInnerValueHelper(d, NS"QObject *", sender.sender);
                    d.endHash();
                    d.beginHash();
                        P(d, "name", "[" << s << "] signal");
                        P(d, "type", "");
                        P(d, "value", method.signature());
                        P(d, "numchild", "0");
                    d.endHash();
                    d.beginHash();
                        P(d, "name", "[" << s << "] type");
                        P(d, "type", "");
                        P(d, "value", "<" << qConnectionTypes[conn.method] << " connection>");
                        P(d, "numchild", "0");
                    d.endHash();
                }
            }
        }
        d << "]";
        P(d, "numchild", numchild);
    }
#endif
    d.disarm();
}

static void qDumpQObjectSlotList(QDumper &d)
{
    const QObject *ob = reinterpret_cast<const QObject *>(d.data);
#if QT_VERSION >= 0x040400
    const QObjectPrivate *p = reinterpret_cast<const QObjectPrivate *>(dfunc(ob));
#endif
    const QMetaObject *mo = ob->metaObject();

    int count = 0;
    for (int i = mo->methodCount(); --i >= 0; )
        count += (mo->method(i).methodType() == QMetaMethod::Slot);

    P(d, "addr", d.data);
    P(d, "numchild", count);
#if QT_VERSION >= 0x040400
    if (d.dumpChildren) {
        d << ",children=[";
        for (int i = 0; i != mo->methodCount(); ++i) {
            const QMetaMethod & method = mo->method(i);
            if (method.methodType() == QMetaMethod::Slot) {
                d.beginHash();
                int k = mo->indexOfSlot(method.signature());
                P(d, "name", "[" << k << "]");
                P(d, "value", method.signature());

                // count senders. expensive...
                int numchild = 0;
                for (int s = 0; s != p->senders.size(); ++s) {
                    const QObjectPrivate::Sender & sender = p->senders.at(s);
                    const QObjectPrivate::ConnectionList &connList
                        = qConnectionList(sender.sender, sender.signal);
                    for (int c = 0; c != connList.size(); ++c) {
                        const QObjectPrivate::Connection &conn = connList.at(c);
                        if (conn.receiver == ob && conn.method == k)
                            ++numchild;
                    }
                }
                P(d, "numchild", numchild);
                P(d, "exp", "*(class '"NS"QObject'*)" << d.data);
                P(d, "type", NS"QObjectSlot");
                d.endHash();
            }
        }
        d << "]";
    }
#endif
    d.disarm();
}
#endif // PRIVATE_OBJECT_ALLOWED


static void qDumpQPixmap(QDumper &d)
{
#ifdef QT_GUI_LIB
    const QPixmap &im = *reinterpret_cast<const QPixmap *>(d.data);
    P(d, "value", "(" << im.width() << "x" << im.height() << ")");
    P(d, "type", NS"QPixmap");
    P(d, "numchild", "0");
    d.disarm();
#else
    Q_UNUSED(d);
#endif
}

static void qDumpQSet(QDumper &d)
{
    // This uses the knowledge that QHash<T> has only a single member
    // of  union { QHashData *d; QHashNode<Key, T> *e; };
    QHashData *hd = *(QHashData**)d.data;
    QHashData::Node *node = hd->firstNode();

    int n = hd->size;
    if (n < 0)
        qCheck(false);
    if (n > 0) {
        qCheckAccess(node);
        qCheckPointer(node->next);
    }

    P(d, "value", "<" << n << " items>");
    P(d, "valuedisabled", "true");
    P(d, "numchild", 2 * n);
    if (d.dumpChildren) {
        if (n > 100)
            n = 100;
        d << ",children=[";
        int i = 0;
        for (int bucket = 0; bucket != hd->numBuckets && i <= 10000; ++bucket) {
            for (node = hd->buckets[bucket]; node->next; node = node->next) {
                d.beginHash();
                P(d, "name", "[" << i << "]");
                P(d, "type", d.innertype);
                P(d, "exp", "(('"NS"QHashNode<" << d.innertype
                    << ","NS"QHashDummyValue>'*)"
                    << static_cast<const void*>(node) << ")->key"
                );
                d.endHash();
                ++i;
                if (i > 10000) {
                    d.putEllipsis();
                    break;
                }
            }
        }
        d << "]";
    }
    d.disarm();
}

static void qDumpQString(QDumper &d)
{
    const QString &str = *reinterpret_cast<const QString *>(d.data);

    if (!str.isEmpty()) {
        qCheckAccess(str.unicode());
        qCheckAccess(str.unicode() + str.size());
    }

    P(d, "value", str);
    P(d, "valueencoded", "1");
    P(d, "type", NS"QString");
    //P(d, "editvalue", str);  // handled generically below
    P(d, "numchild", "0");

    d.disarm();
}

static void qDumpQStringList(QDumper &d)
{
    const QStringList &list = *reinterpret_cast<const QStringList *>(d.data);
    int n = list.size();
    if (n < 0)
        qCheck(false);
    if (n > 0) {
        qCheckAccess(&list.front());
        qCheckAccess(&list.back());
    }

    P(d, "value", "<" << n << " items>");
    P(d, "valuedisabled", "true");
    P(d, "numchild", n);
    P(d, "childtype", NS"QString");
    P(d, "childnumchild", "0");
    if (d.dumpChildren) {
        if (n > 1000)
            n = 1000;
        d << ",children=[";
        for (int i = 0; i != n; ++i) {
            d.beginHash();
            P(d, "name", "[" << i << "]");
            P(d, "value", list[i]);
            P(d, "valueencoded", "1");
            d.endHash();
        }
        if (n < list.size())
            d.putEllipsis();
        d << "]";
    }
    d.disarm();
}

static void qDumpQTextCodec(QDumper &d)
{
    const QTextCodec &codec = *reinterpret_cast<const QTextCodec *>(d.data);
    P(d, "value", codec.name());
    P(d, "valueencoded", "1");
    P(d, "type", NS"QTextCodec");
    P(d, "numchild", "2");
    if (d.dumpChildren) {
        d << ",children=[";
        S(d, "name", codec.name());
        I(d, "mibEnum", codec.mibEnum());
        d << "]";
    }
    d.disarm();
}

static void qDumpQVariantHelper(const void *data, QString *value,
    QString *exp, int *numchild)
{
    const QVariant &v = *reinterpret_cast<const QVariant *>(data);
    switch (v.type()) {
    case QVariant::Invalid:
        *value = QLatin1String("<invalid>");
        *numchild = 0;
        break;
    case QVariant::String:
        *value = QLatin1Char('"') + v.toString() + QLatin1Char('"');
        *numchild = 0;
        break;
    case QVariant::StringList:
        *exp = QString(QLatin1String("((QVariant*)%1)->d.data.c"))
                    .arg((quintptr)data);
        *numchild = v.toStringList().size();
        break;
    case QVariant::Int:
        *value = QString::number(v.toInt());
        *numchild= 0;
        break;
    case QVariant::Double:
        *value = QString::number(v.toDouble());
        *numchild = 0;
        break;
    default: {
        char buf[1000];
        const char *format = (v.typeName()[0] == 'Q')
            ?  "'"NS"%s "NS"qVariantValue<"NS"%s >'(*('"NS"QVariant'*)%p)"
            :  "'%s "NS"qVariantValue<%s >'(*('"NS"QVariant'*)%p)";
        qsnprintf(buf, sizeof(buf) - 1, format, v.typeName(), v.typeName(), data);
        *exp = QLatin1String(buf);
        *numchild = 1;
        break;
        }
    }
}

static void qDumpQVariant(QDumper &d)
{
    const QVariant &v = *reinterpret_cast<const QVariant *>(d.data);
    QString value;
    QString exp;
    int numchild = 0;
    qDumpQVariantHelper(d.data, &value, &exp, &numchild);
    bool isInvalid = (v.typeName() == 0);
    if (isInvalid) {
        P(d, "value", "(invalid)");
    } else if (value.isEmpty()) {
        P(d, "value", "(" << v.typeName() << ") " << qPrintable(value));
    } else {
        QByteArray ba;
        ba += '(';
        ba += v.typeName();
        ba += ") ";
        ba += qPrintable(value);
        P(d, "value", ba);
        P(d, "valueencoded", "1");
    }
    P(d, "type", NS"QVariant");
    P(d, "numchild", (isInvalid ? "0" : "1"));
    if (d.dumpChildren) {
        d << ",children=[";
        d.beginHash();
        P(d, "name", "value");
        if (!exp.isEmpty())
            P(d, "exp", qPrintable(exp));
        if (!value.isEmpty()) {
            P(d, "value", value);
            P(d, "valueencoded", "1");
        }
        P(d, "type", v.typeName());
        P(d, "numchild", numchild);
        d.endHash();
        d << "]";
    }
    d.disarm();
}

static void qDumpQVector(QDumper &d)
{
    QVectorData *v = *reinterpret_cast<QVectorData *const*>(d.data);

    // Try to provoke segfaults early to prevent the frontend
    // from asking for unavailable child details
    int nn = v->size;
    if (nn < 0)
        qCheck(false);
    if (nn > 0) {
        //qCheckAccess(&vec.front());
        //qCheckAccess(&vec.back());
    }

    unsigned innersize = d.extraInt[0];
    unsigned typeddatasize = d.extraInt[1];

    int n = nn;
    P(d, "value", "<" << n << " items>");
    P(d, "valuedisabled", "true");
    P(d, "numchild", n);
    if (d.dumpChildren) {
        QByteArray strippedInnerType = stripPointerType(d.innertype);
        const char *stripped =
            isPointerType(d.innertype) ? strippedInnerType.data() : 0;
        if (n > 1000)
            n = 1000;
        d << ",children=[";
        for (int i = 0; i != n; ++i) {
            d.beginHash();
            P(d, "name", "[" << i << "]");