debugger: start splitting off python and non-python specific bits

src/plugins/debugger/gdb/gdb.pri

@@ -19,6 +19,8 @@ HEADERS += \
 SOURCES += \
     $$PWD/gdbmi.cpp \
     $$PWD/gdbengine.cpp \
+    $$PWD/classicgdbengine.cpp \
+    $$PWD/pythongdbengine.cpp \
     $$PWD/gdboptionspage.cpp \
     $$PWD/trkoptions.cpp \
     $$PWD/trkoptionswidget.cpp \

src/plugins/debugger/gdb/gdbengine.h

@@ -264,17 +264,17 @@ private: ////////// Gdb Output, State & Capability Handling //////////
     void handleStop1(const GdbMi &data);
     StackFrame parseStackFrame(const GdbMi &mi, int level);
 
-    virtual bool isSynchroneous() const;
+    virtual bool hasPython() const;
     bool supportsThreads() const;
 
     // Gdb initialization sequence
     void handleShowVersion(const GdbResponse &response);
-    void handleIsSynchroneous(const GdbResponse &response);
+    void handleHasPython(const GdbResponse &response);
 
     int m_gdbVersion; // 6.8.0 is 60800
     int m_gdbBuildVersion; // MAC only?
     bool m_isMacGdb;
-    bool m_isSynchronous; // Can act synchronously?
+    bool m_hasPython;
 
 private: ////////// Inferior Management //////////
 
@@ -393,10 +393,11 @@ private: ////////// View & Data Stuff //////////
     // Stack specific stuff
     //
     void updateAll();
+        void updateAllClassic();
+        void updateAllPython();
     void handleStackListFrames(const GdbResponse &response);
     void handleStackSelectThread(const GdbResponse &response);
     void handleStackListThreads(const GdbResponse &response);
-    void handleStackFrame(const GdbResponse &response);
     Q_SLOT void reloadStack(bool forceGotoLocation);
     Q_SLOT virtual void reloadFullStack();
     int currentFrame() const;
@@ -418,7 +419,7 @@ private: ////////// View & Data Stuff //////////
     void handleWatchPoint(const GdbResponse &response);
 
     // FIXME: BaseClass. called to improve situation for a watch item
-    void updateSubItem(const WatchData &data);
+    void updateSubItemClassic(const WatchData &data);
     void handleChildren(const WatchData &parent, const GdbMi &child,
         QList<WatchData> *insertions);
 
@@ -429,10 +430,10 @@ private: ////////// View & Data Stuff //////////
 
     void insertData(const WatchData &data);
     void sendWatchParameters(const QByteArray &params0);
-    void createGdbVariable(const WatchData &data);
+    void createGdbVariableClassic(const WatchData &data);
 
-    void runDebuggingHelper(const WatchData &data, bool dumpChildren);
-    void runDirectDebuggingHelper(const WatchData &data, bool dumpChildren);
+    void runDebuggingHelperClassic(const WatchData &data, bool dumpChildren);
+    void runDirectDebuggingHelperClassic(const WatchData &data, bool dumpChildren);
     bool hasDebuggingHelperForType(const QString &type) const;
 
     void handleVarListChildren(const GdbResponse &response);
@@ -442,20 +443,25 @@ private: ////////// View & Data Stuff //////////
     void handleVarAssign(const GdbResponse &response);
     void handleEvaluateExpression(const GdbResponse &response);
     //void handleToolTip(const GdbResponse &response);
-    void handleQueryDebuggingHelper(const GdbResponse &response);
-    void handleDebuggingHelperValue2(const GdbResponse &response);
-    void handleDebuggingHelperValue3(const GdbResponse &response);
+    void handleQueryDebuggingHelperClassic(const GdbResponse &response);
+    void handleDebuggingHelperValue2Classic(const GdbResponse &response);
+    void handleDebuggingHelperValue3Classic(const GdbResponse &response);
     void handleDebuggingHelperEditValue(const GdbResponse &response);
     void handleDebuggingHelperSetup(const GdbResponse &response);
 
     void updateLocals(const QVariant &cookie = QVariant());
-    void handleStackListLocals(const GdbResponse &response);
-    void handleStackListLocals0(const GdbResponse &response);
+        void updateLocalsClassic(const QVariant &cookie);
+        void updateLocalsPython(const QByteArray &varList);
+            void handleStackFramePython(const GdbResponse &response);
+        
+    void handleStackListLocalsClassic(const GdbResponse &response);
+    void handleStackListLocalsPython(const GdbResponse &response);
+
     WatchData localVariable(const GdbMi &item,
                             const QStringList &uninitializedVariables,
                             QMap<QByteArray, int> *seen);
     void setLocals(const QList<GdbMi> &locals);
-    void handleStackListArguments(const GdbResponse &response);
+    void handleStackListArgumentsClassic(const GdbResponse &response);
     void setWatchDataType(WatchData &data, const GdbMi &mi);
     void setWatchDataDisplayedType(WatchData &data, const GdbMi &mi);
 
@@ -465,13 +471,14 @@ private: ////////// View & Data Stuff //////////
 private: ////////// Dumper Management //////////
     QString qtDumperLibraryName() const;
     bool checkDebuggingHelpers();
-    void setDebuggingHelperState(DebuggingHelperState);
-    void tryLoadDebuggingHelpers();
-    void tryQueryDebuggingHelpers();
-    Q_SLOT void recheckDebuggingHelperAvailability();
+        bool checkDebuggingHelpersClassic();
+    void setDebuggingHelperStateClassic(DebuggingHelperState);
+    void tryLoadDebuggingHelpersClassic();
+    void tryQueryDebuggingHelpersClassic();
+    Q_SLOT void recheckDebuggingHelperAvailabilityClassic();
     void connectDebuggingHelperActions();
     void disconnectDebuggingHelperActions();
-    Q_SLOT void setDebugDebuggingHelpers(const QVariant &on);
+    Q_SLOT void setDebugDebuggingHelpersClassic(const QVariant &on);
     Q_SLOT void setUseDebuggingHelpers(const QVariant &on);
 
     const bool m_dumperInjectionLoad;
@@ -486,7 +493,9 @@ private: ////////// Convenience Functions //////////
     void debugMessage(const QString &msg);
     QMainWindow *mainWindow() const;
 
-    void updateLocalsSync(const QByteArray &varList);
+    static QString m_toolTipExpression;
+    static QPoint m_toolTipPos;
+    static QByteArray tooltipINameForExpression(const QByteArray &exp);
 };
 
 } // namespace Internal

src/plugins/debugger/gdb/pythongdbengine.cpp

+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** Commercial Usage
+**
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://qt.nokia.com/contact.
+**
+**************************************************************************/
+
+#include "gdbengine.h"
+
+#include "abstractgdbadapter.h"
+#include "debuggeractions.h"
+#include "debuggerstringutils.h"
+
+#include "watchhandler.h"
+#include "stackhandler.h"
+
+#include <utils/qtcassert.h>
+
+#define PRECONDITION QTC_ASSERT(hasPython(), /**/)
+#define CB(callback) &GdbEngine::callback, STRINGIFY(callback)
+
+
+namespace Debugger {
+namespace Internal {
+
+void GdbEngine::updateLocalsPython(const QByteArray &varList)
+{
+    PRECONDITION;
+    if (m_gdbAdapter->isTrkAdapter()) {
+        postCommand("-stack-list-locals 0",
+            WatchUpdate, CB(handleStackListLocalsPython));
+        return;
+    }
+    m_processedNames.clear();
+    manager()->watchHandler()->beginCycle();
+    //m_toolTipExpression.clear();
+    WatchHandler *handler = m_manager->watchHandler();
+
+    QByteArray expanded;
+    QSet<QByteArray> expandedINames = handler->expandedINames();
+    QSetIterator<QByteArray> jt(expandedINames);
+    while (jt.hasNext()) {
+        expanded.append(jt.next());
+        expanded.append(',');
+    }
+    if (expanded.isEmpty())
+        expanded.append("defaults,");
+    expanded.chop(1);
+
+    QByteArray watchers;
+    if (!m_toolTipExpression.isEmpty())
+        watchers += m_toolTipExpression.toLatin1()
+            + "#" + tooltipINameForExpression(m_toolTipExpression.toLatin1());
+
+    QHash<QByteArray, int> watcherNames = handler->watcherNames();
+    QHashIterator<QByteArray, int> it(watcherNames);
+    while (it.hasNext()) {
+        it.next();
+        if (!watchers.isEmpty())
+            watchers += "##";
+        if (it.key() == WatchHandler::watcherEditPlaceHolder().toLatin1())
+            watchers += "<Edit>#watch." + QByteArray::number(it.value());
+        else
+            watchers += it.key() + "#watch." + QByteArray::number(it.value());
+    }
+
+    QByteArray options;
+    if (theDebuggerBoolSetting(UseDebuggingHelpers))
+        options += "fancy,";
+    if (theDebuggerBoolSetting(AutoDerefPointers))
+        options += "autoderef,";
+    if (options.isEmpty())
+        options += "defaults,";
+    options.chop(1);
+
+    postCommand("bb " + options + " @" + varList + ' '
+            + expanded + ' ' + watchers.toHex(),
+        WatchUpdate, CB(handleStackFramePython));
+}
+
+void GdbEngine::handleStackListLocalsPython(const GdbResponse &response)
+{
+    PRECONDITION;
+    if (response.resultClass == GdbResultDone) {
+        // 44^done,data={locals=[name="model",name="backString",...]}
+        QByteArray varList = "vars"; // Dummy entry, will be stripped by dumper.
+        foreach (const GdbMi &child, response.data.findChild("locals").children()) {
+            varList.append(',');
+            varList.append(child.data());
+        }
+        updateLocalsPython(varList);
+    }
+}
+
+void GdbEngine::handleStackFramePython(const GdbResponse &response)
+{
+    PRECONDITION;
+    if (response.resultClass == GdbResultDone) {
+        QByteArray out = response.data.findChild("consolestreamoutput").data();
+        while (out.endsWith(' ') || out.endsWith('\n'))
+            out.chop(1);
+        //qDebug() << "SECOND CHUNK: " << out;
+        int pos = out.indexOf("data=");
+        if (pos != 0) {
+            qDebug() << "DISCARDING JUNK AT BEGIN OF RESPONSE: "
+                << out.left(pos);
+            out = out.mid(pos);
+        }
+        GdbMi all;
+        all.fromStringMultiple(out);
+        //qDebug() << "ALL: " << all.toString();
+        
+        GdbMi data = all.findChild("data");
+        QList<WatchData> list;
+        foreach (const GdbMi &child, data.children()) {
+            WatchData dummy;
+            dummy.iname = child.findChild("iname").data();
+            dummy.name = _(child.findChild("name").data());
+            //qDebug() << "CHILD: " << child.toString();
+            handleChildren(dummy, child, &list);
+        }
+        manager()->watchHandler()->insertBulkData(list);
+        //for (int i = 0; i != list.size(); ++i)
+        //    qDebug() << "LOCAL: " << list.at(i).toString();
+
+        //PENDING_DEBUG("AFTER handleStackFrame()");
+        // FIXME: This should only be used when updateLocals() was
+        // triggered by expanding an item in the view.
+        if (m_pendingRequests <= 0) {
+            //PENDING_DEBUG("\n\n ....  AND TRIGGERS MODEL UPDATE\n");
+            rebuildModel();
+        }
+    } else {
+        debugMessage(_("DUMPER FAILED: " + response.toString()));
+    }
+}
+
+// Called from CoreAdapter and AttachAdapter
+void GdbEngine::updateAllPython()
+{
+    PRECONDITION;
+    //PENDING_DEBUG("UPDATING ALL\n");
+    QTC_ASSERT(state() == InferiorUnrunnable || state() == InferiorStopped, /**/);
+    reloadModulesInternal();
+    postCommand("-stack-list-frames", WatchUpdate, CB(handleStackListFrames),
+        QVariant::fromValue<StackCookie>(StackCookie(false, true)));
+    manager()->stackHandler()->setCurrentIndex(0);
+    if (supportsThreads())
+        postCommand("-thread-list-ids", WatchUpdate, CB(handleStackListThreads), 0);
+    manager()->reloadRegisters();
+    updateLocals(); 
+}
+
+} // namespace Internal
+} // namespace Debugger

src/plugins/debugger/gdb/termgdbadapter.cpp

@@ -100,7 +100,7 @@ void TermGdbAdapter::startAdapter()
         var += QLatin1Char('=');
         var += m_engine->qtDumperLibraryName();
         environment.push_back(var);
-        m_engine->setDebuggingHelperState(DebuggingHelperLoadTried);
+        m_engine->setDebuggingHelperStateClassic(DebuggingHelperLoadTried);
     }
     m_stubProc.setEnvironment(environment);
     // FIXME: Starting the stub implies starting the inferior. This is