Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdevelop@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1414 insertions, 0 deletions

diff --git a/languages/ruby/debugger/rdbcontroller.cpp b/languages/ruby/debugger/rdbcontroller.cpp
new file mode 100644
index 00000000..160754a0
--- /dev/null
+++ b/languages/ruby/debugger/rdbcontroller.cpp
@@ -0,0 +1,1414 @@
+// *************************************************************************
+//                          rdbcontroller.cpp  -  description
+//                             -------------------
+//    begin                : Sun Aug 8 1999
+//    copyright            : (C) 1999 by John Birch
+//    email                : jbb@kdevelop.org
+//	
+//                          Adapted for ruby debugging
+//                          --------------------------
+//    begin                : Mon Nov 1 2004
+//    copyright            : (C) 2004 by Richard Dale
+//    email                : Richard_Dale@tipitina.demon.co.uk
+// **************************************************************************
+//
+// **************************************************************************
+// *                                                                        *
+// *   This program is free software; you can redistribute it and/or modify *
+// *   it under the terms of the GNU General Public License as published by *
+// *   the Free Software Foundation; either version 2 of the License, or    *
+// *   (at your option) any later version.                                  *
+// *                                                                        *
+// **************************************************************************
+
+#include "rdbcontroller.h"
+
+#include <sys/types.h> 
+#include <fcntl.h>
+#include <sys/socket.h> 
+#include <sys/un.h>
+#include <errno.h>
+
+#include "breakpoint.h"
+#include "framestackwidget.h"
+#include "rdbcommand.h"
+#include "stty.h"
+#include "variablewidget.h"
+#include "domutil.h"
+#include "settings.h"
+
+#include <kapplication.h>
+#include <kconfig.h>
+#include <kdebug.h>
+#include <kglobal.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kprocess.h>
+
+#include <qdatetime.h>
+#include <qfileinfo.h>
+#include <qregexp.h>
+#include <qstring.h>
+#include <qtextstream.h>
+
+#include <iostream>
+#include <ctype.h>
+#include <stdlib.h>
+using namespace std;
+
+// **************************************************************************
+//
+// Does all the communication between rdb and the kdevelop's debugger code.
+// Significatant classes being used here are
+//
+// RDBParser  - parses the "variable" data using the vartree and varitems
+// VarTree    - where the variable data will end up
+// FrameStack - tracks the program frames and allows the user to switch between
+//              and therefore view the calling funtions and their data
+// Breakpoint - Where and what to do with breakpoints.
+// STTY       - the tty that the _application_ will run on.
+//
+// Significant variables
+// state_     - be very careful setting this. The controller is totally
+//              dependent on this reflecting the correct state. For instance,
+//              if the app is busy but we don't think so, then we lose control
+//              of the app. The only way to get out of these situations is to
+//              delete (stop) the controller.
+// currentFrame_
+//            - Holds the frame number where and locals/variable information will
+//              go to
+//
+//
+// **************************************************************************
+
+namespace RDBDebugger
+{
+
+// This is here so we can check for startup /shutdown problems
+int debug_controllerExists = false;
+
+// At the moment a Unix domain socket is used. It might be better to
+// change to tcp/ip and listen on a port instead
+QCString RDBController::unixSocketPath_;
+
+
+RDBController::RDBController(VariableTree *varTree, FramestackWidget *frameStack, QDomDocument &projectDom)
+        : DbgController(),
+        frameStack_(frameStack),
+        varTree_(varTree),
+        currentFrame_(1),
+        viewedThread_(-1),
+        stdoutOutputLen_(0),
+        stdoutOutput_(new char[4096]),
+        holdingZone_(),
+        rdbOutputLen_(0),
+        rdbOutput_(new char[49152]),
+		socketNotifier_(0),
+        currentCmd_(0),
+		currentPrompt_("(rdb:1) "),
+        tty_(0),
+        state_(s_dbgNotStarted|s_appNotStarted|s_silent),
+        programHasExited_(false),
+        dom(projectDom),
+        config_forceBPSet_(true),
+        config_dbgTerminal_(false)
+{
+    struct sockaddr_un	sockaddr;
+	unixSocketPath_.sprintf("/tmp/.rubydebugger%d", getpid());
+	QFileInfo			unixSocket(unixSocketPath_);
+	
+    stdoutSizeofBuf_ = sizeof(stdoutOutput_);
+    rdbSizeofBuf_ = sizeof(rdbOutput_);
+    
+	if (unixSocket.exists()) {
+		unlink(unixSocketPath_);
+	}
+	
+	masterSocket_ = socket(AF_UNIX, SOCK_STREAM, 0);
+	sockaddr.sun_family = AF_UNIX;
+	strcpy(sockaddr.sun_path, unixSocketPath_);
+	bind(masterSocket_, (const struct sockaddr*) &sockaddr, sizeof(sockaddr));
+	listen(masterSocket_, 1);
+	acceptNotifier_ = new QSocketNotifier(masterSocket_, QSocketNotifier::Read, this);
+    QObject::connect( acceptNotifier_, SIGNAL(activated(int)),
+                          this, SLOT(slotAcceptConnection(int)) );	
+						  	
+    configure();
+    cmdList_.setAutoDelete(true);
+
+    Q_ASSERT(! debug_controllerExists);
+    debug_controllerExists = true;
+}
+
+// **************************************************************************
+
+// Deleting the controller involves shutting down rdb nicely.
+// When were attached to a process, we must first detach so that the process
+// can continue running as it was before being attached. rdb is quite slow to
+// detach from a process, so we must process events within here to get a "clean"
+// shutdown.
+RDBController::~RDBController()
+{
+    delete[] stdoutOutput_;
+    delete[] rdbOutput_;
+    debug_controllerExists = false;
+
+	QFileInfo unixSocket(unixSocketPath_);
+	if (unixSocket.exists()) {
+		unlink(unixSocketPath_);
+	}
+}
+
+// **************************************************************************
+
+void RDBController::configure()
+{    
+}
+
+// **************************************************************************
+
+// Fairly obvious that we'll add whatever command you give me to a queue
+// If you tell me to, I'll put it at the head of the queue so it'll run ASAP
+// Not quite so obvious though is that if we are going to run again. then any
+// information requests become redundent and must be removed.
+// We also try and run whatever command happens to be at the head of
+// the queue.
+void RDBController::queueCmd(DbgCommand *cmd, bool executeNext)
+{
+    // We remove any info command or _run_ command if we are about to
+    // add a run command.
+    if (cmd->isARunCmd())
+        removeInfoRequests();
+
+    if (executeNext)
+        cmdList_.insert(0, cmd);
+    else
+        cmdList_.append (cmd);
+}
+
+// **************************************************************************
+
+// If the appliction can accept a command and we've got one waiting
+// then send it.
+// Commands can be just request for data (or change rdbs state in someway)
+// or they can be "run" commands. If a command is sent to rdb our internal
+// state will get updated.
+void RDBController::executeCmd()
+{
+    if (stateIsOn(s_dbgNotStarted|s_waitForWrite|s_appBusy|s_shuttingDown) || !dbgProcess_)
+        return;
+
+    if (currentCmd_ == 0) {
+        if (cmdList_.isEmpty())
+            return;
+
+        currentCmd_ = cmdList_.take(0);
+    }
+
+    if (!currentCmd_->moreToSend()) {
+        delete currentCmd_;
+        if (cmdList_.isEmpty()) {
+            currentCmd_ = 0;
+            return;
+        }
+
+        currentCmd_ = cmdList_.take(0);
+    }
+    
+	char * ptr = currentCmd_->cmdToSend().data();
+	int bytesToWrite = currentCmd_->cmdLength();
+	int bytesWritten = 0;
+	
+	while (bytesToWrite > 0) {
+    	bytesWritten = write(socket_, ptr, bytesToWrite);
+		bytesToWrite -= bytesWritten;
+		ptr += bytesWritten;
+	}
+	
+    if (currentCmd_->isARunCmd()) {
+        setStateOn(s_appBusy);
+        kdDebug(9012) << "App is busy" << endl;
+        setStateOff(s_appNotStarted|s_programExited|s_silent);
+    }
+
+    QString prettyCmd = currentCmd_->cmdToSend();
+    prettyCmd = currentPrompt_ + prettyCmd;
+    emit rdbStdout( prettyCmd.latin1() );
+	
+    if (!stateIsOn(s_silent))
+        emit dbgStatus("", state_);
+}
+
+// **************************************************************************
+
+void RDBController::destroyCmds()
+{
+    if (currentCmd_)
+    {
+        delete currentCmd_;
+        currentCmd_ = 0;
+    }
+
+    while (!cmdList_.isEmpty())
+        delete cmdList_.take(0);
+}
+
+// **********************************************************************
+
+void RDBController::removeInfoRequests()
+{
+    int i = cmdList_.count();
+    while (i)
+    {
+        i--;
+        DbgCommand *cmd = cmdList_.at(i);
+        if (cmd->isAnInfoCmd() || cmd->isARunCmd())
+            delete cmdList_.take(i);
+    }
+}
+
+// **********************************************************************
+
+// Pausing an app removes any pending run commands so that the app doesn't
+// start again. If we want to be silent then we remove any pending info
+// commands as well.
+void RDBController::pauseApp()
+{
+    int i = cmdList_.count();
+    while (i)
+    {
+        i--;
+        DbgCommand *cmd = cmdList_.at(i);
+        if ((stateIsOn(s_silent) && cmd->isAnInfoCmd()) || cmd->isARunCmd())
+            delete cmdList_.take(i);
+    }
+
+    if (dbgProcess_ && stateIsOn(s_appBusy))
+        dbgProcess_->kill(SIGINT);
+}
+
+// **********************************************************************
+
+// Whenever the program pauses we need to refresh the data visible to
+// the user. The reason we've stopped may be passed in  to be emitted.
+void RDBController::actOnProgramPause(const QString &msg)
+{
+    // We're only stopping if we were running, of course.
+    if (stateIsOn(s_appBusy))
+    {
+        kdDebug(9012) << "App is paused" << endl;
+        setStateOff(s_appBusy);
+        if (stateIsOn(s_silent))
+            return;
+
+        emit dbgStatus (msg, state_);
+
+        // We're always at frame one when the program stops
+        // and we must reset the active flag
+        currentFrame_ = 1;
+        varTree_->nextActivationId();
+		setStateOn(s_fetchLocals);
+        
+		queueCmd(new RDBCommand("where", NOTRUNCMD, INFOCMD), true);
+        queueCmd(new RDBCommand("thread list", NOTRUNCMD, INFOCMD), true);
+		
+		if (stateIsOn(s_fetchGlobals)) {
+			queueCmd(new RDBCommand("var global", NOTRUNCMD, INFOCMD));
+		}
+		        
+		emit acceptPendingBPs();
+    }
+}
+
+// **************************************************************************
+
+// There is no app anymore. This can be caused by program exiting
+// an invalid program specified or ...
+// rdb is still running though, but only the run command (may) make sense
+// all other commands are disabled.
+void RDBController::programNoApp(const QString &msg, bool msgBox)
+{
+    state_ = (s_appNotStarted|s_programExited|(state_&(s_shuttingDown)));
+    destroyCmds();
+
+    // We're always at frame one when the program stops
+    // and we must reset the active flag
+    viewedThread_ = -1;
+    currentFrame_ = 1;
+    varTree_->nextActivationId();
+
+    // Now wipe the tree out
+    varTree_->viewport()->setUpdatesEnabled(false);
+    varTree_->prune();
+    varTree_->viewport()->setUpdatesEnabled(true);
+    varTree_->repaint();
+
+    frameStack_->clear();
+
+    if (msgBox)
+        KMessageBox::error(0, i18n("rdb message:\n")+msg);
+
+    emit dbgStatus (msg, state_);
+}
+
+// **************************************************************************
+
+// The program location falls out of rdb. We treat
+// it as a wrapped command.
+// The data gets parsed here and emitted in its component parts.
+void RDBController::parseProgramLocation(char *buf)
+{
+	QString buffer(buf);
+	QString line;
+	QTextStream input(&buffer, IO_ReadOnly);
+	QString sourceFile;
+	int sourceLine = 0;
+	
+    //  "1: a = 1"
+    QRegExp display_re("^(\\d+):\\s(.*)$");
+	
+    //  "/opt/qt/src/widgets/qlistview.rb:1558:puts 'hello world'"
+    QRegExp sourcepos_re("^([^:]+):(\\d+):");
+		
+	line = input.readLine();
+	while (! line.isNull()) {
+ 		if (sourcepos_re.search(line, 0) >= 0) {
+			sourceFile = sourcepos_re.cap(1);
+			sourceLine = sourcepos_re.cap(2).toInt();
+    	} else if (display_re.search(line, 0) >= 0) {
+			varTree_->watchRoot()->updateWatchExpression(display_re.cap(1).toInt(), display_re.cap(2));
+		}
+		
+		line = input.readLine();
+	}
+
+	if ( !sourceFile.isNull() 
+		&& (	traceIntoRuby_ 
+				|| (	!sourceFile.endsWith("/qtruby.rb")
+						&& !sourceFile.endsWith("/korundum.rb") ) )
+		&& !sourceFile.endsWith("/debuggee.rb") ) 
+	{
+        actOnProgramPause(QString());
+        emit showStepInSource(sourceFile, sourceLine, "");
+		return;
+	}
+	
+    if (stateIsOn(s_appBusy))
+        actOnProgramPause(i18n("No source: %1").arg(sourceFile));
+    else
+        emit dbgStatus (i18n("No source: %1").arg(sourceFile), state_);
+}
+
+// **************************************************************************
+
+// parsing the backtrace list will cause the vartree to be refreshed
+void RDBController::parseBacktraceList(char *buf)
+{
+    frameStack_->parseRDBBacktraceList(buf);
+}
+
+// **************************************************************************
+
+void RDBController::parseThreadList(char *buf)
+{
+	frameStack_->parseRDBThreadList(buf);
+    viewedThread_ = frameStack_->viewedThread();
+    varTree_->setCurrentThread(viewedThread_);
+}
+
+// **************************************************************************
+
+void RDBController::parseSwitchThread(char *buf)
+{
+	// Look for the thread number
+	// 2 #<Thread:0x30091998 sleep>   /home/duke/play/testit/trykorundum/src/bar.rb:13
+    QRegExp thread_re("(\\d+)");
+	if (thread_re.search(buf) != -1) {
+		viewedThread_ = thread_re.cap(1).toInt();
+		currentFrame_ = 1;
+	}
+}
+
+// **************************************************************************
+
+// After an 'up nnn' or 'down nnn' command, get the new source file and line no.
+void RDBController::parseFrameMove(char *buf)
+{
+	QString sourceFile;
+	int sourceLine = 0;
+	
+    if (stateIsOn(s_fetchLocals)) {
+		return;
+	}
+	
+	// "#2 /home/duke/play/testit/trykorundum/src/main.rb:11"
+    QRegExp sourcepos_re("#\\d+\\s([^:]+):(\\d+)");
+	if (sourcepos_re.search(buf) != -1) {
+		sourceFile = sourcepos_re.cap(1);
+		sourceLine = sourcepos_re.cap(2).toInt();
+		
+		if (	!sourceFile.isNull()
+				&& (	traceIntoRuby_ 
+						|| (	!sourceFile.endsWith("/qtruby.rb")
+								&& !sourceFile.endsWith("/korundum.rb") ) )
+				&& !sourceFile.endsWith("/debuggee.rb") )
+		{ 
+        	emit showStepInSource(sourceFile, sourceLine, "");
+			return;
+		}
+	}
+	
+	emit dbgStatus(i18n("No source: %1").arg(sourceFile), state_);
+}
+
+// **************************************************************************
+
+// When a breakpoint has been set, rdb responds with some data about the
+// new breakpoint. We just inform the breakpoint system about this.
+void RDBController::parseBreakpointSet(char *buf)
+{
+    if (RDBSetBreakpointCommand *BPCmd = dynamic_cast<RDBSetBreakpointCommand*>(currentCmd_))
+    {
+        // ... except in this case :-) A -1 key tells us that this is
+        // a special internal breakpoint, and we shouldn't do anything
+        // with it. Currently there are _no_ internal breakpoints.
+        if (BPCmd->getKey() != -1) {
+            emit rawRDBBreakpointSet(buf, BPCmd->getKey());
+		}
+    }
+}
+
+// **************************************************************************
+
+// Extra data needed by an item was requested. Here's the result.
+// If it's an ordinary 'p ' command then just echo the result on
+// the RDB console and don't bother parsing.
+void RDBController::parseRequestedData(char *buf)
+{
+    if (RDBItemCommand *rdbItemCommand = dynamic_cast<RDBItemCommand*> (currentCmd_))
+    {
+        // Fish out the item from the command and let it deal with the data
+        VarItem *item = rdbItemCommand->getItem();
+        varTree_->viewport()->setUpdatesEnabled(false);
+        item->expandValue(buf);
+        varTree_->viewport()->setUpdatesEnabled(true);
+        varTree_->repaint();
+    }
+}
+
+
+// **************************************************************************
+
+// Select a different frame to view. We need to get and (maybe) display
+// where we are in the program source.
+void RDBController::parseFrameSelected(char *buf)
+{
+    if (!stateIsOn(s_silent)) {
+        emit showStepInSource("", -1, "");
+        emit dbgStatus (i18n("No source: %1").arg(QString(buf)), state_);
+    }
+}
+
+// **************************************************************************
+
+// Sets the id of the display in the VarTree and a current value.
+void RDBController::parseDisplay(char *buf, char * expr)
+{
+    varTree_->viewport()->setUpdatesEnabled(false);
+    varTree_->watchRoot()->setWatchExpression(buf, expr);
+    varTree_->viewport()->setUpdatesEnabled(true);
+    varTree_->repaint();
+}
+
+// **************************************************************************
+
+// Updates the watch expressions with current values
+void RDBController::parseUpdateDisplay(char *buf)
+{
+	varTree_->viewport()->setUpdatesEnabled(false);
+	
+    QRegExp display_re("(\\d+):\\s([^\n]*)\n");
+	
+	int pos = display_re.search(buf);
+	while (pos != -1) {
+		varTree_->watchRoot()->updateWatchExpression(display_re.cap(1).toInt(), display_re.cap(2));
+		
+		pos += display_re.matchedLength();
+		pos = display_re.search(buf, pos);
+	}
+
+    varTree_->viewport()->setUpdatesEnabled(true);
+    varTree_->repaint();
+}
+
+// **************************************************************************
+
+// This is called on program stop to process the globals.
+void RDBController::parseGlobals(char *buf)
+{
+    varTree_->viewport()->setUpdatesEnabled(false);
+    varTree_->globalRoot()->setGlobals(buf);
+    varTree_->viewport()->setUpdatesEnabled(true);
+    varTree_->repaint();
+}
+
+// **************************************************************************
+
+// This is called on program stop to process the locals.
+// Once the locals have been processed we prune the tree of items that are
+// inactive.
+void RDBController::parseLocals(char type, char *buf)
+{
+    varTree_->viewport()->setUpdatesEnabled(false);
+
+    // The locals are always attached to the currentFrame
+    VarFrameRoot *frame = varTree_->findFrame(currentFrame_, viewedThread_);
+    if (!frame)
+    {
+        frame = new VarFrameRoot(varTree_, currentFrame_, viewedThread_);
+        frame->setFrameName(
+                frameStack_->findFrame(currentFrame_, viewedThread_)->frameName());
+    }
+
+    Q_ASSERT(frame);
+	
+    if (type == (char) CONSTANTS) {
+        frame->addLocals(buf);
+    } else if (type == (char) CVARS) {
+        frame->addLocals(buf);
+    } else if (type == (char) IVARS) {
+        frame->addLocals(buf);
+    } else {
+        frame->addLocals(buf);
+        frame->setLocals();
+	}
+
+    varTree_->viewport()->setUpdatesEnabled(true);
+    varTree_->repaint();
+}
+
+
+
+// **************************************************************************
+
+void RDBController::parse(char *buf)
+{
+	if (currentCmd_ == 0) {
+		return;
+	}
+	
+	if (currentCmd_->isARunCmd()) {
+        parseProgramLocation(buf);
+	} else if (currentCmd_->rawDbgCommand() == "break") {
+        emit rawRDBBreakpointList(buf);
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "break ", strlen("break ")) == 0) {
+		parseBreakpointSet(buf); 
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "watch ", strlen("watch ")) == 0) {
+		parseBreakpointSet(buf); 
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "display ", strlen("display ")) == 0) {
+		parseDisplay(buf, currentCmd_->rawDbgCommand().data() + strlen("display "));
+	} else if (currentCmd_->rawDbgCommand() == "display") {
+		parseUpdateDisplay(buf);
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "undisplay ", strlen("undisplay ")) == 0) {
+		;
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "method instance ", strlen("method instance ")) == 0) { 
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "method ", strlen("method ")) == 0) {
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "pp ", strlen("pp ")) == 0) {
+		parseRequestedData(buf);
+	} else if (currentCmd_->rawDbgCommand() == "thread list") {
+		parseThreadList(buf);
+	} else if (	qstrncmp(currentCmd_->rawDbgCommand(), "up ", strlen("up ")) == 0
+				|| qstrncmp(currentCmd_->rawDbgCommand(), "down ", strlen("down ")) == 0 ) 
+	{
+		parseFrameMove(buf);
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "thread switch ", strlen("thread switch ")) == 0) {
+		parseSwitchThread(buf);
+	} else if (currentCmd_->rawDbgCommand() == "thread current") {
+		parseThreadList(buf);
+	} else if (currentCmd_->rawDbgCommand() == "where") {
+		parseBacktraceList(buf);
+	} else if (currentCmd_->rawDbgCommand() == "var global") {
+		parseGlobals(buf);
+	} else if (currentCmd_->rawDbgCommand() == "var local") {
+		parseLocals(LOCALS, buf);
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "var instance ", strlen("var instance ")) == 0) {
+		parseLocals(IVARS, buf);
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "var class ", strlen("var class ")) == 0) {
+		parseLocals(CVARS, buf);
+	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "var const ", strlen("var const ")) == 0) {
+		parseLocals(CONSTANTS, buf);
+	}
+
+    return;
+}
+
+// **************************************************************************
+
+void RDBController::setBreakpoint(const QCString &BPSetCmd, int key)
+{
+    queueCmd(new RDBSetBreakpointCommand(BPSetCmd, key));
+}
+
+// **************************************************************************
+
+void RDBController::clearBreakpoint(const QCString &BPClearCmd)
+{
+    queueCmd(new RDBCommand(BPClearCmd, NOTRUNCMD, NOTINFOCMD));
+    // Note: this is NOT an info command, because rdb doesn't explictly tell
+    // us that the breakpoint has been deleted, so if we don't have it the
+    // BP list doesn't get updated.
+    queueCmd(new RDBCommand("break", NOTRUNCMD, NOTINFOCMD));
+}
+
+// **************************************************************************
+
+void RDBController::modifyBreakpoint( const Breakpoint& BP )
+{
+    Q_ASSERT(BP.isActionModify());
+    if (BP.dbgId() > 0)
+    {
+        if (BP.changedEnable())
+            queueCmd(new RDBCommand(QCString().sprintf("%s %d",
+                            BP.isEnabled() ? "enable" : "disable",
+                            BP.dbgId()), NOTRUNCMD, NOTINFOCMD));
+
+        //        BP.setDbgProcessing(true);
+        // Note: this is NOT an info command, because rdb doesn't explictly tell
+        // us that the breakpoint has been deleted, so if we don't have it the
+        // BP list doesn't get updated.
+        queueCmd(new RDBCommand("break", NOTRUNCMD, NOTINFOCMD));
+    }
+}
+
+// **************************************************************************
+//                                SLOTS
+//                                *****
+// For most of these slots data can only be sent to rdb when it
+// isn't busy and it is running.
+
+// **************************************************************************
+
+void RDBController::slotStart(const QString& ruby_interpreter, const QString& character_coding, const QString& run_directory, const QString& debuggee_path, const QString &application, const QString& run_arguments, bool show_constants, bool trace_into_ruby)
+{
+    Q_ASSERT (!dbgProcess_ && !tty_);
+	
+//    tty_ = new STTY(config_dbgTerminal_, "konsole");
+    tty_ = new STTY(config_dbgTerminal_, Settings::terminalEmulatorName( *kapp->config() ));
+    if (!config_dbgTerminal_)
+    {
+        connect( tty_, SIGNAL(OutOutput(const char*)), SIGNAL(ttyStdout(const char*)) );
+        connect( tty_, SIGNAL(ErrOutput(const char*)), SIGNAL(ttyStderr(const char*)) );
+    }
+
+    QString tty(tty_->getSlave());
+    if (tty.isEmpty())
+    {
+        KMessageBox::error(0, i18n("The ruby debugger cannot use the tty* or pty* devices.\n"
+                                   "Check the settings on /dev/tty* and /dev/pty*\n"
+                                   "As root you may need to \"chmod ug+rw\" tty* and pty* devices "
+                                   "and/or add the user to the tty group using "
+                                   "\"usermod -G tty username\"."));
+
+        delete tty_;
+        tty_ = 0;
+        return;
+    }
+
+    dbgProcess_ = new KProcess;
+
+    connect( dbgProcess_, SIGNAL(receivedStdout(KProcess *, char *, int)),
+             this,        SLOT(slotDbgStdout(KProcess *, char *, int)) );
+
+    connect( dbgProcess_, SIGNAL(receivedStderr(KProcess *, char *, int)),
+             this,        SLOT(slotDbgStderr(KProcess *, char *, int)) );
+
+    connect( dbgProcess_, SIGNAL(wroteStdin(KProcess *)),
+             this,        SLOT(slotDbgWroteStdin(KProcess *)) );
+
+    connect( dbgProcess_, SIGNAL(processExited(KProcess*)),
+             this,        SLOT(slotDbgProcessExited(KProcess*)) );
+
+	rubyInterpreter_ = ruby_interpreter;
+	characterCoding_ = character_coding;
+	runDirectory_ = run_directory;
+	debuggeePath_ = debuggee_path;
+	application_ = application;
+	runArguments_ = run_arguments;
+	showConstants_ = show_constants;
+	traceIntoRuby_ = trace_into_ruby;
+
+	*dbgProcess_ << ruby_interpreter;
+	*dbgProcess_ << character_coding;
+	*dbgProcess_ << "-C" << QString(QFile::encodeName( run_directory ));
+	*dbgProcess_ << "-r" << debuggee_path;
+	*dbgProcess_ << application;
+	
+	if (!run_arguments.isNull() && !run_arguments.isEmpty()) {
+		*dbgProcess_ << run_arguments;
+	}
+
+    emit rdbStdout(QString( ruby_interpreter + " " + character_coding
+							+ " -C " + QString(QFile::encodeName( run_directory ))
+							+ " -r " + debuggee_path + " " 
+							+ application + " " + run_arguments ).latin1() );
+
+    if (!dbgProcess_->start( KProcess::NotifyOnExit,
+                        KProcess::Communication(KProcess::All)) )
+	{
+        kdDebug(9012) << "Couldn't start ruby debugger" << endl;
+	}
+
+    // Initialise rdb. At this stage rdb is sitting wondering what to do,
+    // and to whom. Organise a few things, then set up the tty for the application,
+    // and the application itself
+
+    // Now the ruby debugger has been started and the application has been loaded,
+    // BUT the app hasn't been started yet! A run command is about to be issued
+    // by whoever is controlling us.
+	
+    if (!dbgProcess_->writeStdin(QString("%1\n").arg(unixSocketPath_).latin1(), strlen(unixSocketPath_) + 1)) {
+        kdDebug(9012) << "failed to write Unix domain socket path to rdb " 
+		<< QString("%1\n").arg(unixSocketPath_).latin1() << endl;
+	}
+	
+	setStateOff(s_programExited);
+	setStateOn(s_dbgNotStarted|s_appNotStarted|s_silent);
+}
+
+// **************************************************************************
+
+void RDBController::slotStopDebugger()
+{
+    if (stateIsOn(s_shuttingDown) || !dbgProcess_)
+        return;
+
+    setStateOn(s_shuttingDown|s_silent);
+    destroyCmds();
+
+    QTime start;
+    QTime now;
+
+    // Get rdb's attention if it's busy. We need rdb to be at the
+    // command line so we can stop it.
+    if (stateIsOn(s_appBusy))
+    {
+        kdDebug(9012) << "ruby debugger busy on shutdown - stopping rdb (SIGINT)" << endl;
+        dbgProcess_->kill(SIGINT);
+        start = QTime::currentTime();
+        while (-1)
+        {
+            kapp->processEvents(20);
+            now = QTime::currentTime();
+            if (!stateIsOn(s_appBusy) || start.msecsTo( now ) > 2000)
+                break;
+        }
+    }
+
+
+    // Now try to stop the ruby debugger running.
+    kdDebug(9012) << "App is busy" << endl;
+    setStateOn(s_appBusy);
+    const char *quit="quit\n";
+    if (!dbgProcess_->writeStdin(quit, strlen(quit)))
+        kdDebug(9012) << "failed to write 'quit' to ruby debugger" << endl;
+
+    emit rdbStdout("(rdb:1) quit");
+    start = QTime::currentTime();
+    while (-1)
+    {
+         kapp->processEvents(20);
+         now = QTime::currentTime();
+         if (stateIsOn(s_programExited) || start.msecsTo( now ) > 2000)
+             break;
+    }
+
+    // We cannot wait forever.
+    if (!stateIsOn(s_programExited))
+    {
+        kdDebug(9012) << "rdb not shutdown - killing" << endl;
+        dbgProcess_->kill(SIGKILL);
+    }
+
+    delete dbgProcess_;    dbgProcess_ = 0;
+    delete tty_;           tty_ = 0;
+
+    state_ = s_dbgNotStarted | s_appNotStarted | s_silent;
+    emit dbgStatus (i18n("Debugger stopped"), state_);
+}
+
+
+
+// **************************************************************************
+
+void RDBController::slotRun()
+{
+	if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown))
+        return;
+		
+	if (stateIsOn(s_programExited)) {
+		slotStart(rubyInterpreter_, characterCoding_, runDirectory_, debuggeePath_, application_, runArguments_, showConstants_, traceIntoRuby_);
+		return;
+	}
+
+    queueCmd(new RDBCommand("cont", RUNCMD, NOTINFOCMD));
+	if (currentCmd_ == 0) {
+    	executeCmd();
+	}
+}
+
+// **************************************************************************
+
+void RDBController::slotRunUntil(const QString &fileName, int lineNum)
+{
+    if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown))
+        return;
+
+    if (fileName.isEmpty())
+        queueCmd(new RDBCommand( QCString().sprintf("break %d", lineNum),
+                                RUNCMD, NOTINFOCMD));
+    else
+        queueCmd(new RDBCommand(
+                QCString().sprintf("break %s:%d", fileName.latin1(), lineNum),
+                                RUNCMD, NOTINFOCMD));
+    queueCmd(new RDBCommand("cont", RUNCMD, NOTINFOCMD));
+								
+	if (currentCmd_ == 0) {
+    	executeCmd();
+	}
+}
+
+// **************************************************************************
+
+void RDBController::slotStepInto()
+{
+    if (stateIsOn(s_appBusy|s_appNotStarted|s_shuttingDown))
+        return;
+
+    queueCmd(new RDBCommand("step", RUNCMD, NOTINFOCMD));
+	if (currentCmd_ == 0) {
+    	executeCmd();
+	}
+}
+
+
+// **************************************************************************
+
+void RDBController::slotStepOver()
+{
+    if (stateIsOn(s_appBusy|s_appNotStarted|s_shuttingDown))
+        return;
+
+    queueCmd(new RDBCommand("next", RUNCMD, NOTINFOCMD));
+	if (currentCmd_ == 0) {
+    	executeCmd();
+	}
+}
+
+
+// **************************************************************************
+
+void RDBController::slotStepOutOff()
+{
+    if (stateIsOn(s_appBusy|s_appNotStarted|s_shuttingDown))
+        return;
+
+    queueCmd(new RDBCommand("finish", RUNCMD, NOTINFOCMD));
+	if (currentCmd_ == 0) {
+    	executeCmd();
+	}
+}
+
+// **************************************************************************
+
+// Only interrupt a running program.
+void RDBController::slotBreakInto()
+{
+    pauseApp();
+}
+
+// **************************************************************************
+
+// See what, if anything needs doing to this breakpoint.
+void RDBController::slotBPState( const Breakpoint& BP )
+{
+	// Are we in a position to do anything to this breakpoint?
+    if (stateIsOn(s_dbgNotStarted|s_shuttingDown) || !BP.isPending() ||
+            BP.isActionDie())
+        return;
+
+    // We need this flag so that we can continue execution. I did use
+    // the s_silent state flag but it can be set prior to this method being
+    // called, hence is invalid.
+    bool restart = false;
+    if (stateIsOn(s_appBusy))
+    {
+        if (!config_forceBPSet_)
+            return;
+
+        // When forcing breakpoints to be set/unset, interrupt a running app
+        // and change the state.
+        setStateOn(s_silent);
+        pauseApp();
+        restart = true;
+    }
+
+    if (BP.isActionAdd())
+    {
+        setBreakpoint(BP.dbgSetCommand().latin1(), BP.key());
+        //        BP.setDbgProcessing(true);
+    }
+    else
+    {
+        if (BP.isActionClear())
+        {
+            clearBreakpoint(BP.dbgRemoveCommand().latin1());
+            //            BP.setDbgProcessing(true);
+        }
+        else
+        {
+            if (BP.isActionModify())
+            {
+                modifyBreakpoint(BP); // Note: DbgProcessing gets set in modify fn
+            }
+        }
+    }
+
+    if (restart)
+        queueCmd(new RDBCommand("cont", RUNCMD, NOTINFOCMD));
+}
+
+// **************************************************************************
+
+void RDBController::slotClearAllBreakpoints()
+{
+    // Are we in a position to do anything to this breakpoint?
+    if (stateIsOn(s_dbgNotStarted|s_shuttingDown))
+        return;
+
+    bool restart = false;
+    if (stateIsOn(s_appBusy))
+    {
+        if (!config_forceBPSet_)
+            return;
+
+        // When forcing breakpoints to be set/unset, interrupt a running app
+        // and change the state.
+        setStateOn(s_silent);
+        pauseApp();
+        restart = true;
+    }
+
+    queueCmd(new RDBCommand("delete", NOTRUNCMD, NOTINFOCMD));
+    // Note: this is NOT an info command, because rdb doesn't explictly tell
+    // us that the breakpoint has been deleted, so if we don't have it the
+    // BP list doesn't get updated.
+    queueCmd(new RDBCommand("break", NOTRUNCMD, NOTINFOCMD));
+
+    if (restart)
+        queueCmd(new RDBCommand("cont", RUNCMD, NOTINFOCMD));
+		
+	executeCmd();
+}
+
+
+
+// **************************************************************************
+
+void RDBController::slotSelectFrame(int frameNo, int threadNo, const QString& frameName)
+{
+	if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown)) {
+		kdDebug(9012) << "RDBController::slotSelectFrame wrong state" << endl;
+        return;
+	}
+
+	if (viewedThread_ != threadNo) {
+		// Note that 'thread switch nnn' is a run command
+		queueCmd(new RDBCommand(QCString().sprintf("thread switch %d",
+                                threadNo), RUNCMD, INFOCMD));
+		executeCmd();
+		return;
+	}
+		
+	if (frameNo > currentFrame_) {
+    	queueCmd(new RDBCommand(QCString().sprintf("up %d", frameNo - currentFrame_), NOTRUNCMD, INFOCMD));
+		if (!stateIsOn(s_fetchLocals)) {
+        	queueCmd(new RDBCommand("display", NOTRUNCMD, INFOCMD));
+		}
+	} else if (frameNo < currentFrame_) {
+    	queueCmd(new RDBCommand(QCString().sprintf("down %d", currentFrame_ - frameNo), NOTRUNCMD, INFOCMD));
+		if (!stateIsOn(s_fetchLocals)) {
+        	queueCmd(new RDBCommand("display", NOTRUNCMD, INFOCMD));
+		}
+	}
+
+    // Hold on to  this thread/frame so that we know where to put the local
+    // variables if generated.
+    viewedThread_ = threadNo;
+    currentFrame_ = frameNo;
+
+    VarFrameRoot *frame = varTree_->findFrame(frameNo, viewedThread_);
+    if (frame == 0) {
+        frame = new VarFrameRoot(varTree_, currentFrame_, viewedThread_);
+    }
+		
+	frame->setFrameName(frameName);
+	varTree_->setSelected(frame, true);
+	
+	// Have we already got these details?
+	if (frame->needsVariables()) {
+		// Ask for the locals
+
+		if (showConstants_) {
+        	queueCmd(new RDBCommand("var const self.class", NOTRUNCMD, INFOCMD));
+		}
+
+		queueCmd(new RDBCommand("var instance self", NOTRUNCMD, INFOCMD));
+		queueCmd(new RDBCommand("var class self.class", NOTRUNCMD, INFOCMD));
+		queueCmd(new RDBCommand("var local", NOTRUNCMD, INFOCMD));
+		frame->startWaitingForData();
+    }
+	
+	if (currentCmd_ == 0) {
+		executeCmd();
+	}
+	
+	return;
+}
+
+
+
+// **************************************************************************
+
+// This is called when an item needs special processing to show a value.
+void RDBController::slotExpandItem(VarItem *item, const QCString &userRequest)
+{
+	if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown))
+        return;
+
+    Q_ASSERT(item != 0);
+
+    // Bad user data!!
+    if (userRequest.isEmpty())
+        return;
+
+    queueCmd(new RDBItemCommand(item, QCString("pp ") + userRequest.data(), false));
+	
+	if (currentCmd_ == 0) {
+		executeCmd();
+	}
+}
+
+// **************************************************************************
+
+// This method evaluates text selected with the 'Inspect:' context menu
+void RDBController::slotRubyInspect(const QString &inspectText)
+{
+    queueCmd(new RDBCommand(	QCString().sprintf("p %s", inspectText.latin1()), 
+								NOTRUNCMD, 
+								INFOCMD ), true );
+	executeCmd();
+}
+
+
+// **************************************************************************
+
+// Add a new expression to be displayed in the Watch variable tree
+void RDBController::slotAddWatchExpression(const QString& expr, bool execute)
+{
+	queueCmd(new RDBCommand(	QCString().sprintf("display %s", expr.latin1()), 
+								NOTRUNCMD, 
+								NOTINFOCMD ) );
+	if (execute) {
+		executeCmd();
+	}
+}
+
+// **************************************************************************
+
+// Add a new expression to be displayed in the Watch variable tree
+void RDBController::slotRemoveWatchExpression(int displayId)
+{
+    queueCmd(new RDBCommand(	QCString().sprintf("undisplay %d", displayId), 
+								NOTRUNCMD, 
+								INFOCMD ) );
+	executeCmd();
+}
+
+
+// **************************************************************************
+
+// The user will only get globals if the Global frame is open
+void RDBController::slotFetchGlobals(bool fetch)
+{
+    if (fetch) {
+        setStateOn(s_fetchGlobals);
+		queueCmd(new RDBCommand("var global", NOTRUNCMD, INFOCMD));
+		executeCmd();
+    } else {
+        setStateOff(s_fetchGlobals);
+	}
+
+    kdDebug(9012) << (fetch ? "<Globals ON>": "<Globals OFF>") << endl;
+}
+
+// **************************************************************************
+
+// Data from the ruby program's stdout gets processed here.
+void RDBController::slotDbgStdout(KProcess *, char *buf, int buflen)
+{
+    QCString msg(buf, buflen+1);
+    emit ttyStdout(msg);
+}
+
+// **************************************************************************
+
+// Data from the ruby program's stderr gets processed here.
+void RDBController::slotDbgStderr(KProcess *, char *buf, int buflen)
+{
+    QCString msg(buf, buflen+1);
+    emit ttyStderr(msg);
+}
+
+// **************************************************************************
+
+void RDBController::slotDbgWroteStdin(KProcess *)
+{
+//    setStateOff(s_waitForWrite);
+    //  if (!stateIsOn(s_silent))
+    //    emit dbgStatus ("", state_);
+//    executeCmd();
+}
+
+// **************************************************************************
+
+void RDBController::slotAcceptConnection(int masterSocket)
+{
+    Q_ASSERT(masterSocket == masterSocket_);
+	
+	struct sockaddr sockaddr;
+	socklen_t fromlen;
+	
+	if (socketNotifier_ != 0) {
+		close(socket_);
+		delete socketNotifier_;
+	}
+	
+	socket_ = accept(masterSocket, &sockaddr, &fromlen);
+	if (fcntl(socket_, F_SETFL, O_NONBLOCK) == -1) {
+    	kdDebug(9012) << "RDBController::slotAcceptConnection can't set nonblocking socket " << errno << endl;
+	}
+	
+	socketNotifier_ = new QSocketNotifier(socket_, QSocketNotifier::Read, 0);
+    QObject::connect( socketNotifier_, SIGNAL(activated(int)),
+                          this, SLOT(slotReadFromSocket(int)) );	
+    
+	setStateOff(s_dbgNotStarted);
+    emit dbgStatus ("", state_);
+    
+	cmdList_.clear();
+	rdbOutputLen_ = 0;	
+	
+	// Organise any breakpoints.
+    emit acceptPendingBPs();
+
+	if (traceIntoRuby_) {
+        queueCmd(new RDBCommand("trace_ruby on", NOTRUNCMD, NOTINFOCMD));
+	}
+		
+    queueCmd(new RDBCommand("cont", RUNCMD, NOTINFOCMD));
+	
+ 	// Reset the display id for any watch expressions already in the variable tree
+	varTree_->resetWatchVars();
+}
+
+// **************************************************************************
+
+// Output from rdb via the Unix socket gets processed here.
+void RDBController::slotReadFromSocket(int socket)
+{
+	Q_ASSERT(socket == socket_);
+    
+	static bool parsing = false;
+
+	int bytesRead = read(socket, rdbOutput_ + rdbOutputLen_, rdbSizeofBuf_);
+	
+	rdbOutputLen_ += bytesRead;
+    *(rdbOutput_ + rdbOutputLen_) = 0;
+	
+
+    // Already parsing? then get out quick.
+    if (parsing)
+    {
+        kdDebug(9012) << "Already parsing" << endl;
+        return;
+    }
+
+//    kdDebug(9012) << "RDBController::slotReadFromSocket length: " << rdbOutputLen_ << " input: " << rdbOutput_ << endl;
+	
+	QRegExp prompt_re("(\\(rdb:(\\d+)\\) )$");
+ 	int promptPos = prompt_re.search(rdbOutput_, 0);
+	
+	// Keep appending output to the rbdOutput_ buffer until the
+	// ruby debugger writes the next prompt
+    if (promptPos == -1) {
+		return;
+	}
+	
+//    kdDebug(9012) << "RDBController::slotReadFromSocket length: " << rdbOutputLen_ << " input: " << rdbOutput_ << endl;
+	
+	// Save the prompt, and remove it from the buffer
+	currentPrompt_ = prompt_re.cap(1).latin1();
+	rdbOutputLen_ -= prompt_re.matchedLength();
+   	*(rdbOutput_ + rdbOutputLen_) = 0;	
+    
+	emit rdbStdout(rdbOutput_);
+
+    parsing = true;
+    parse(rdbOutput_);
+    parsing = false;
+	rdbOutputLen_ = 0;
+	
+	executeCmd();
+	
+	if (currentCmd_ == 0 && stateIsOn(s_fetchLocals)) {
+		if (!varTree_->schedule()) {
+			setStateOff(s_fetchLocals);
+		}
+	}
+}
+
+// **************************************************************************
+
+void RDBController::slotDbgProcessExited(KProcess*)
+{
+    destroyCmds();
+    state_ = s_appNotStarted|s_programExited|(state_&(s_shuttingDown));
+    emit dbgStatus (i18n("Process exited"), state_);
+    emit rdbStdout("(rdb:1) Process exited\n");
+	frameStack_->clear();
+	varTree_->clear();	
+	
+	if (socketNotifier_ != 0) {
+		delete socketNotifier_;
+		socketNotifier_ = 0;
+		close(socket_);
+	}
+	
+    delete dbgProcess_;    dbgProcess_ = 0;
+    delete tty_;           tty_ = 0;
+}
+
+
+// **************************************************************************
+
+// Takes abbreviated commands and expands them, before passing them on to rdb
+//
+void RDBController::slotUserRDBCmd(const QString& cmd)
+{
+    kdDebug(9012) << "Requested user cmd: " << cmd << endl;
+    QRegExp break_re("^b(reak)?(\\s.*)?");
+    QRegExp watch_re("^wat(ch)?\\s+(.*)");
+    QRegExp delete_re("^del(ete)?(\\s.*)?");
+    QRegExp display_re("^disp(lay)?(\\s.*)?");
+    QRegExp undisplay_re("^undisp(lay)?(\\s.*)?");
+    QRegExp step_re("^s(tep)?(\\s[\\d]+)?$");
+    QRegExp next_re("^n(ext)?(\\s[\\d]+)?$");
+    QRegExp varlocal_re("^v(ar)?\\s+l(ocal)?");
+    QRegExp varglobal_re("^v(ar)?\\s+g(lobal)?");
+    QRegExp varinstance_re("^v(ar)?\\s+i(nstance)?\\s(.*)");
+    QRegExp varconst_re("^v(ar)?\\s+c(onst)?\\s(.*)");
+    QRegExp threadlist_re("^th(read)?\\s+l(ist)?");
+    QRegExp threadcurrent_re("^th(read)?(\\sc(ur(rent)?)?)?$");
+    QRegExp threadswitch_re("^th(read)?(\\ssw(itch)?)?(\\s.*)");
+    QRegExp thread_re("^th(read)?(\\s+.*)?");
+    QRegExp methodinstance_re("^m(ethod)?\\s+i(nstance)?\\s+(.*)");
+    QRegExp method_re("^m(ethod)?\\s+(.*)");
+    QRegExp list_re("^l(ist)?(\\s+\\d+-\\d+)?$");
+    
+    if ( break_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("break%s", break_re.cap(2).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if ( watch_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("watch %s", watch_re.cap(2).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if ( delete_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("delete%s", delete_re.cap(2).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if ( display_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("display%s", display_re.cap(2).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if ( undisplay_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("undisplay%s", undisplay_re.cap(2).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if ( step_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("step%s", step_re.cap(2).latin1()), 
+									RUNCMD, 
+									INFOCMD ), true );
+    } else if ( next_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("next%s", next_re.cap(2).latin1()), 
+									RUNCMD, 
+									INFOCMD ), true );
+    } else if ( varlocal_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand("var local", NOTRUNCMD, INFOCMD));
+    } else if ( varglobal_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand("var global", NOTRUNCMD, INFOCMD));
+    } else if ( varinstance_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("var instance %s", varinstance_re.cap(3).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if ( varconst_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("var const %s", varconst_re.cap(3).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if ( methodinstance_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("method instance %s", methodinstance_re.cap(3).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if ( method_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("method %s", method_re.cap(2).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if ( list_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("list%s", list_re.cap(2).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+	} else if (cmd == "c" || cmd == "cont") {
+        queueCmd(new RDBCommand("cont", RUNCMD, NOTINFOCMD));
+	} else if (cmd == "fi" || cmd == "finish") {
+        queueCmd(new RDBCommand("finish", RUNCMD, NOTINFOCMD));
+    } else if ( threadlist_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand("thread list", NOTRUNCMD, INFOCMD), true);
+    } else if ( threadcurrent_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand("thread current", NOTRUNCMD, INFOCMD), true );
+    } else if ( threadswitch_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("thread switch%s", threadswitch_re.cap(4).latin1()), 
+									RUNCMD, 
+									INFOCMD ), true );
+    } else if ( thread_re.search(cmd) >= 0 ) {
+        queueCmd(new RDBCommand(	QCString().sprintf("thread%s", thread_re.cap(2).latin1()), 
+									NOTRUNCMD, 
+									INFOCMD ), true );
+    } else if (cmd == "frame" || cmd == "f" || cmd == "where" || cmd == "w") {
+        queueCmd(new RDBCommand("where", NOTRUNCMD, INFOCMD), true);
+    } else if (cmd == "q" || cmd == "quit") {
+        slotStopDebugger();
+        return;
+    } else {
+    	kdDebug(9012) << "Passing directly to rdb: " << cmd << endl;
+    	queueCmd(new RDBCommand(cmd.latin1(), NOTRUNCMD, INFOCMD));
+	}
+	
+    executeCmd();
+}
+
+}
+
+// **************************************************************************
+// **************************************************************************
+// **************************************************************************
+#include "rdbcontroller.moc"