diff options
Diffstat (limited to 'languages/ruby/debugger')
38 files changed, 9712 insertions, 0 deletions
diff --git a/languages/ruby/debugger/Makefile.am b/languages/ruby/debugger/Makefile.am new file mode 100644 index 00000000..f4c512c2 --- /dev/null +++ b/languages/ruby/debugger/Makefile.am @@ -0,0 +1,25 @@ +# Here resides the debugger part. + +INCLUDES = -I$(top_srcdir)/languages/lib/debugger \ + -I$(top_srcdir)/lib/interfaces -I$(top_srcdir)/lib/interfaces/extensions -I$(top_srcdir)/lib/util \ + -I$(top_srcdir)/lib/widgets $(all_includes) + +kde_module_LTLIBRARIES = libkdevrbdebugger.la +libkdevrbdebugger_la_LDFLAGS = $(all_libraries) $(KDE_PLUGIN) +libkdevrbdebugger_la_LIBADD = $(top_builddir)/lib/libkdevelop.la $(top_builddir)/lib/widgets/libkdevwidgets.la $(LIB_KHTML) \ + $(top_builddir)/languages/lib/debugger/liblang_debugger.la + +libkdevrbdebugger_la_SOURCES = debuggerpart.cpp dbgcontroller.cpp rdbcontroller.cpp dbgcommand.cpp rdbcommand.cpp rdbparser.cpp stty.cpp breakpoint.cpp variablewidget.cpp rdbbreakpointwidget.cpp framestackwidget.cpp dbgpsdlg.cpp dbgtoolbar.cpp rdboutputwidget.cpp rdbtable.cpp + +METASOURCES = AUTO +KDE_ICON = AUTO + +rubysrc_DATA = debuggee.rb +rubysrcdir = $(kde_datadir)/kdevrbdebugger + +servicedir = $(kde_servicesdir) +service_DATA = kdevrbdebugger.desktop + +rcdir = $(kde_datadir)/kdevrbdebugger +rc_DATA = kdevrbdebugger.rc +noinst_HEADERS = rdbtable.h diff --git a/languages/ruby/debugger/breakpoint.cpp b/languages/ruby/debugger/breakpoint.cpp new file mode 100644 index 00000000..f210e359 --- /dev/null +++ b/languages/ruby/debugger/breakpoint.cpp @@ -0,0 +1,343 @@ +/*************************************************************************** + begin : Tue May 13 2003 + copyright : (C) 2003 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 "breakpoint.h" + +#include <klocale.h> + +#include <qfileinfo.h> +#include <qfontmetrics.h> +#include <qpainter.h> +#include <qregexp.h> +#include <qstring.h> + +#include <stdio.h> + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +namespace RDBDebugger +{ + +static int BPKey_ = 0; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +Breakpoint::Breakpoint(bool temporary, bool enabled) + : s_pending_(true), + s_actionAdd_(true), + s_actionClear_(false), + s_actionModify_(false), + s_actionDie_(false), + s_dbgProcessing_(false), + s_enabled_(enabled), + s_temporary_(temporary), + s_changedEnable_(false), + key_(BPKey_++), + active_(-1) +{ +} + +/***************************************************************************/ + +Breakpoint::~Breakpoint() +{ +} + +/***************************************************************************/ + +QString Breakpoint::dbgRemoveCommand() const +{ +// if (dbgId_>0) +// return QString("delete %1").arg(dbgId_); // gdb command - not translatable + + return QString(); +} + +/***************************************************************************/ + +// called when debugger ends +void Breakpoint::reset() +{ + dbgId_ = -1; + s_pending_ = true; + s_actionAdd_ = true; // waiting for the debugger to start + s_actionClear_ = false; + s_changedEnable_ = !s_enabled_; + s_actionModify_ = s_changedEnable_; + s_dbgProcessing_ = false; +// hits_ = 0; + active_ = -1; +} + +/***************************************************************************/ + +void Breakpoint::setActive(int active, int id) +{ + active_ = active; + dbgId_ = id; + + if (s_pending_ && !(s_actionAdd_ && s_actionModify_)) { + s_pending_ = false; + s_actionModify_ = false; + } + + s_actionAdd_ = false; + s_actionClear_ = false; + s_actionDie_ = false; + s_dbgProcessing_ = false; + + if (!s_actionModify_) { + s_changedEnable_ = false; + } +} + +/***************************************************************************/ + +QString Breakpoint::statusDisplay(int activeFlag) const +{ + QString status=""; + if (!s_enabled_) + status = i18n("Disabled"); + else + if (s_pending_) + { + if (s_actionAdd_) + status = i18n("Pending (add)"); + if (s_actionClear_) + status = i18n("Pending (clear)"); + if (s_actionModify_) + status = i18n("Pending (modify)"); + } + else + if (isActive(activeFlag)) + status = i18n("Active"); + + return status; +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +FilePosBreakpoint::FilePosBreakpoint(const QString &fileName, int lineNum, + bool temporary, bool enabled) + : Breakpoint(temporary, enabled), + fileName_(fileName), + lineNo_(lineNum) +{ +} + +/***************************************************************************/ + +FilePosBreakpoint::~FilePosBreakpoint() +{ +} + +/***************************************************************************/ + +QString FilePosBreakpoint::dbgSetCommand() const +{ + QString cmdStr; + if (fileName_.isEmpty()) + cmdStr = QString("break %1").arg(lineNo_); // gdb command - not translatable + else { + cmdStr = QString("break %1:%2").arg(fileName_).arg(lineNo_); + } + + if (isTemporary()) + cmdStr = "t"+cmdStr; // gdb command + + return cmdStr; +} + +/***************************************************************************/ + +bool FilePosBreakpoint::match(const Breakpoint *brkpt) const +{ + // simple case + if (this == brkpt) + return true; + + // Type case + const FilePosBreakpoint* check = dynamic_cast<const FilePosBreakpoint*>(brkpt); + if (!check) + return false; + + // member case + return ( (fileName_ == check->fileName_) && + (lineNo_ == check->lineNo_)); +} + +/***************************************************************************/ + +QString FilePosBreakpoint::location(bool compact) +{ + if (compact) + return QFileInfo(fileName_).fileName()+":"+QString::number(lineNo_); + + return fileName_+":"+QString::number(lineNo_); +} + +/***************************************************************************/ + +void FilePosBreakpoint::setLocation(const QString& location) +{ + QRegExp regExp1("(.*):(\\d+)$"); + regExp1.setMinimal(true); + if ( regExp1.search(location, 0) >= 0 ) + { + QString t = regExp1.cap(1); + QString dirPath = QFileInfo(t).dirPath(); + if ( dirPath == "." ) + fileName_ = QFileInfo(fileName_).dirPath()+"/"+regExp1.cap(1); + else + fileName_ = regExp1.cap(1); + + lineNo_ = regExp1.cap(2).toInt(); + } +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +Watchpoint::Watchpoint(const QString& varName, bool temporary, bool enabled) + : Breakpoint(temporary, enabled), + varName_(varName) +{ +} + +/***************************************************************************/ + +Watchpoint::~Watchpoint() +{ +} + +/***************************************************************************/ + +QString Watchpoint::dbgSetCommand() const +{ + return QString("watch ")+varName_; // gdb command - not translatable +} + +/***************************************************************************/ + +bool Watchpoint::match(const Breakpoint* brkpt) const +{ + // simple case + if (this == brkpt) + return true; + + // Type case + const Watchpoint *watch = dynamic_cast<const Watchpoint*>(brkpt); + if (watch == 0) + return false; + + // member case + return (varName_ == watch->varName_); +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +Catchpoint::Catchpoint(const QString& varName, bool temporary, bool enabled) + : Breakpoint(temporary, enabled), + varName_(varName) +{ +} + +/***************************************************************************/ + +Catchpoint::~Catchpoint() +{ +} + +/***************************************************************************/ + +QString Catchpoint::dbgSetCommand() const +{ + return QString("catch ")+varName_; // gdb command - not translatable +} + +/***************************************************************************/ + +bool Catchpoint::match(const Breakpoint* brkpt) const +{ + // simple case + if (this == brkpt) + return true; + + // Type case + const Catchpoint *check = dynamic_cast<const Catchpoint*>(brkpt); + if (check == 0) + return false; + + // member case + return (varName_ == check->varName_); +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +FunctionBreakpoint::FunctionBreakpoint(const QString& functionName, bool temporary, bool enabled) + : Breakpoint(temporary, enabled), + m_functionName(functionName) +{ +} + +/***************************************************************************/ + +FunctionBreakpoint::~FunctionBreakpoint() +{ +} + +/***************************************************************************/ + +QString FunctionBreakpoint::dbgSetCommand() const +{ + return QString("break ")+m_functionName; // gdb command - not translatable +} + +/***************************************************************************/ + +bool FunctionBreakpoint::match(const Breakpoint* brkpt) const +{ + // simple case + if (this == brkpt) + return true; + + // Type case + const FunctionBreakpoint *check = dynamic_cast<const FunctionBreakpoint*>(brkpt); + if (!check) + return false; + + // member case + return (m_functionName == check->m_functionName); +} + + +} diff --git a/languages/ruby/debugger/breakpoint.h b/languages/ruby/debugger/breakpoint.h new file mode 100644 index 00000000..e45e3856 --- /dev/null +++ b/languages/ruby/debugger/breakpoint.h @@ -0,0 +1,214 @@ +/*************************************************************************** + begin : Tue May 13 2003 + copyright : (C) 2003 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. * + * * + ***************************************************************************/ + +#ifndef _BREAKPOINT_H_ +#define _BREAKPOINT_H_ + +#include <klocale.h> + +#include <qstring.h> + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +namespace RDBDebugger +{ + +enum BP_TYPES +{ + BP_TYPE_Invalid, + BP_TYPE_FilePos, + BP_TYPE_Watchpoint, + BP_TYPE_Catchpoint, + BP_TYPE_Function +}; + +class Breakpoint +{ +public: + Breakpoint(bool temporary=false, bool enabled=true); + virtual ~Breakpoint(); + + virtual QString dbgSetCommand() const = 0; + virtual QString dbgRemoveCommand() const; + virtual bool match(const Breakpoint* brkpt) const = 0; + virtual void reset(); + + void setActive(int active, int id); + bool isActive(int active) const { return (active_ == active) || + (s_pending_ && !s_actionClear_); } + void setEnabled(bool enabled) { s_changedEnable_ = (s_enabled_ != enabled); + s_enabled_ = enabled; } + bool isEnabled() const { return s_enabled_; } + void setTemporary(bool temporary) { s_temporary_ = temporary; } + bool isTemporary() const { return s_temporary_; } + + bool changedEnable() const { return s_changedEnable_; } + + void setPending(bool pending) { s_pending_ = pending; } + bool isPending() const { return s_pending_; } + void setActionAdd(bool actionAdd) { s_actionDie_ = false; + s_actionAdd_ = actionAdd; } + bool isActionAdd() const { return s_actionAdd_; } + void setActionClear(bool actionClear) { s_actionClear_ = actionClear; } + bool isActionClear() const { return s_actionClear_; } + void setActionModify(bool actionModify) { s_actionDie_ = false; + s_actionModify_ = actionModify; } + bool isActionModify() const { return s_actionModify_; } + void setDbgProcessing(bool dbgProcessing) { s_dbgProcessing_ = dbgProcessing; } + bool isDbgProcessing() const { return s_dbgProcessing_; } + void setActionDie() { s_actionDie_ = true; + s_actionClear_ = false; } + bool isActionDie() const { return s_actionDie_; } + + int key() const { return key_; } + void setDbgId(int dbgId) { dbgId_ = dbgId; } + int dbgId() const { return dbgId_; } + + virtual QString statusDisplay(int activeFlag) const; + virtual BP_TYPES type() const { return BP_TYPE_Invalid; } + virtual QString displayType() const { return i18n( "Invalid" ); } + + virtual QString location(bool compact=true) = 0; + virtual void setLocation(const QString& ) = 0; + virtual bool isValid() const = 0; + +private: + bool s_pending_ :1; + bool s_actionAdd_ :1; + bool s_actionClear_ :1; + bool s_actionModify_ :1; + bool s_actionDie_ :1; + bool s_dbgProcessing_ :1; + bool s_enabled_ :1; + bool s_temporary_ :1; + bool s_changedEnable_ :1; + + int dbgId_; // assigned by gdb + + int key_; // internal unique key + int active_; // counter incremented on receipt of all BP's + + int ignoreCount_; + QString condition_; +// QString type_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ +class FilePosBreakpoint : public Breakpoint +{ +public: + FilePosBreakpoint(const QString &fileName, int lineNum, + bool temporary=false, bool enabled=true); + virtual ~FilePosBreakpoint(); + virtual QString dbgSetCommand() const; + virtual bool match(const Breakpoint *brkpt) const; + + BP_TYPES type () const { return BP_TYPE_FilePos; } + QString displayType() const { return i18n( "File:line" ); } + void setFileName(const QString& fileName) { fileName_ = fileName; } + QString fileName() const { return fileName_; } + void setLineNum(int lineNum) { lineNo_ = lineNum; } + int lineNum() const { return lineNo_; } + QString location(bool compact=true); + void setLocation(const QString& location); + bool isValid() const { return lineNo_>0 && !fileName_.isEmpty(); } + +private: + QString fileName_; + int lineNo_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ +class Watchpoint : public Breakpoint +{ +public: + Watchpoint(const QString &varName, bool temporary=false, bool enabled=true); + virtual ~Watchpoint(); + virtual QString dbgSetCommand() const; + bool match(const Breakpoint *brkpt) const; + + BP_TYPES type () const { return BP_TYPE_Watchpoint; } + QString displayType() const { return i18n("Watchpoint"); } + void setVarName(const QString& varName) { varName_ = varName; } + QString varName() const { return varName_; } + QString location(bool) { return varName_; } + void setLocation(const QString& location) { varName_ = location; } + bool isValid() const { return !varName_.isEmpty(); } + +private: + QString varName_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ +class Catchpoint : public Breakpoint +{ +public: + Catchpoint(const QString &varName, bool temporary=false, bool enabled=true); + virtual ~Catchpoint(); + virtual QString dbgSetCommand() const; + bool match(const Breakpoint *brkpt) const; + + BP_TYPES type () const { return BP_TYPE_Catchpoint; } + QString displayType() const { return i18n("Catchpoint"); } + void setVarName(const QString& varName) { varName_ = varName; } + QString varName() const { return varName_; } + QString location(bool) { return varName_; } + void setLocation(const QString& location) { varName_ = location; } + bool isValid() const { return !varName_.isEmpty(); } + +private: + QString varName_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ +class FunctionBreakpoint : public Breakpoint +{ +public: + FunctionBreakpoint(const QString &functionName, bool temporary=false, bool enabled=true); + virtual ~FunctionBreakpoint(); + virtual QString dbgSetCommand() const; + bool match(const Breakpoint *brkpt) const; + + BP_TYPES type () const { return BP_TYPE_Function; } + QString displayType() const { return i18n("Method()"); } + void setfunctionName(const QString& functionName) { m_functionName = functionName; } + QString functionName() const { return m_functionName; } + QString location(bool) { return m_functionName; }; + void setLocation(const QString& location) { m_functionName = location; } + bool isValid() const { return !m_functionName.isEmpty(); } + +private: + QString m_functionName; +}; + +} + +#endif diff --git a/languages/ruby/debugger/dbgcommand.cpp b/languages/ruby/debugger/dbgcommand.cpp new file mode 100644 index 00000000..6c6a24ec --- /dev/null +++ b/languages/ruby/debugger/dbgcommand.cpp @@ -0,0 +1,47 @@ +/*************************************************************************** + 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 "dbgcommand.h" + +#include <qstring.h> + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ +namespace RDBDebugger +{ + + +DbgCommand::DbgCommand(const QCString& command, bool isRunCmd, bool isInfoCmd) : + command_(command), + isRunCmd_(isRunCmd), + isInfoCmd_(isInfoCmd), + sent_(false), + waitForReply_(true) +{ + cmdBuffer_ = command_+"\n"; +} + +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ diff --git a/languages/ruby/debugger/dbgcommand.h b/languages/ruby/debugger/dbgcommand.h new file mode 100644 index 00000000..32ec7f7a --- /dev/null +++ b/languages/ruby/debugger/dbgcommand.h @@ -0,0 +1,64 @@ +/*************************************************************************** + 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. * + * * + ***************************************************************************/ + +#ifndef DBGCOMMAND_H +#define DBGCOMMAND_H + +#include <qstring.h> + +/** + * @author John Birch + */ + +namespace RDBDebugger +{ + +class DbgCommand +{ +public: + DbgCommand(const QCString& command, bool isRunCmd, bool isInfoCmd); + virtual ~DbgCommand() {}; + + virtual QCString& cmdToSend() { sent_ = true; return cmdBuffer_; } + virtual int cmdLength() { return cmdBuffer_.length(); } + + QCString rawDbgCommand() const { return command_; } + bool isARunCmd() const { return isRunCmd_;} + bool isAnInfoCmd() const { return isInfoCmd_; } + bool moreToSend() const { return !sent_; } + bool expectReply() const { return waitForReply_; } + +protected: + QCString cmdBuffer_; + QCString command_; + bool isRunCmd_; + bool isInfoCmd_; + bool sent_; + bool waitForReply_; +}; + +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +#endif diff --git a/languages/ruby/debugger/dbgcontroller.cpp b/languages/ruby/debugger/dbgcontroller.cpp new file mode 100644 index 00000000..7ee560b7 --- /dev/null +++ b/languages/ruby/debugger/dbgcontroller.cpp @@ -0,0 +1,46 @@ +/*************************************************************************** + 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 "dbgcontroller.h" +#include <kprocess.h> + +/***************************************************************************/ + +namespace RDBDebugger +{ + +DbgController::DbgController() + : dbgProcess_(0) +{ +} + +/***************************************************************************/ + +DbgController::~DbgController() +{ + delete dbgProcess_; +} + +/***************************************************************************/ + +} + +#include "dbgcontroller.moc" diff --git a/languages/ruby/debugger/dbgcontroller.h b/languages/ruby/debugger/dbgcontroller.h new file mode 100644 index 00000000..13ee4382 --- /dev/null +++ b/languages/ruby/debugger/dbgcontroller.h @@ -0,0 +1,161 @@ +/*************************************************************************** + 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. * + * * + ***************************************************************************/ + +#ifndef _DBGCONTROLLER_H_ +#define _DBGCONTROLLER_H_ + +#include <qobject.h> +#include <domutil.h> + +class KProcess; +class QString; +class QStrList; + +namespace RDBDebugger +{ + +class Breakpoint; +class DbgCommand; +class LazyFetchItem; +class VarItem; + +/***************************************************************************/ +/** + * @author jbb + */ +/***************************************************************************/ +// sigh - namespace's don't work on some of the older compilers +enum DBGStateFlags +{ + s_dbgNotStarted = 1 << 0, + s_appNotStarted = 1 << 1, + s_appBusy = 1 << 2, + s_waitForWrite = 1 << 3, + s_programExited = 1 << 4, + s_silent = 1 << 5, + s_fetchLocals = 1 << 6, + s_viewBT = 1 << 7, + s_viewBP = 1 << 8, + s_attached = 1 << 9, + s_fetchGlobals = 1 << 10, + s_waitTimer = 1 << 11, + s_shuttingDown = 1 << 12, + s_viewThreads = 1 << 13 +}; + + +enum RttiValues { + RTTI_WATCH_ROOT = 1001, + RTTI_GLOBAL_ROOT = 1002, + RTTI_VAR_FRAME_ROOT = 1003, + RTTI_LAZY_FETCH_ITEM = 1004, + RTTI_VAR_ITEM = 1005, + RTTI_WATCH_VAR_ITEM = 1006, + RTTI_THREAD_STACK_ITEM = 1007, + RTTI_FRAME_STACK_ITEM = 1008 +}; + + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ +class DbgController : public QObject +{ + Q_OBJECT + +public: + + DbgController(); + virtual ~DbgController(); + + virtual bool stateIsOn( int state ) = 0; + +protected: + virtual void queueCmd(DbgCommand *cmd, bool executeNext) = 0; + virtual void parse(char *str) = 0; + +public slots: + virtual void configure() = 0; + + /** + * Start the debugger + * \param ruby_interpreter shell + * \param character_coding -K option + * \param run_directory Directory from where the program should be run + * \param debuggee_path Absolute path to debuggee.rb debugger script + * \param application Absolute path to application + * \param run_arguments Command line arguments to be passed to the application + * \param show_constants Show ruby constants in the variables view + */ + virtual void 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) = 0; + + virtual void slotStopDebugger() = 0; + + virtual void slotRun() = 0; + virtual void slotRunUntil(const QString &fileName, int lineNum) = 0; + virtual void slotStepInto() = 0; + virtual void slotStepOver() = 0; + virtual void slotStepOutOff() = 0; + + virtual void slotBreakInto() = 0; + virtual void slotBPState(const Breakpoint&) = 0; + + + virtual void slotExpandItem(VarItem *parent, + const QCString &userRequest) = 0; + virtual void slotSelectFrame(int frame, int thread, + const QString& frameName) = 0; + virtual void slotFetchGlobals(bool fetch) = 0; + +protected slots: + virtual void slotDbgStdout(KProcess *proc, char *buf, int buflen) = 0; + virtual void slotDbgStderr(KProcess*, char*, int) {} ; + virtual void slotDbgWroteStdin(KProcess *proc) = 0; + virtual void slotDbgProcessExited(KProcess *proc) = 0; + + virtual void slotAcceptConnection(int passive_socket) = 0; + virtual void slotReadFromSocket(int socket) = 0; + +signals: + void gotoSourcePosition (const QString &fileName, int lineNum); + void rawRDBBreakpointList (char *buf); + void rawRDBBreakpointSet (char *buf, int key); + void ttyStdout (const char *output); + void ttyStderr (const char *output); + void rdbStdout (const char *output); + void rdbStderr (const char *output); + void showStepInSource (const QString &fileName, int lineNum, const QString &address); + void dbgStatus (const QString &status, int statusFlag); + +protected: + KProcess *dbgProcess_; +}; + +} + +#endif diff --git a/languages/ruby/debugger/dbgpsdlg.cpp b/languages/ruby/debugger/dbgpsdlg.cpp new file mode 100644 index 00000000..83dd1666 --- /dev/null +++ b/languages/ruby/debugger/dbgpsdlg.cpp @@ -0,0 +1,170 @@ +/*************************************************************************** + begin : Mon Sep 20 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 "dbgpsdlg.h" + +#include <kbuttonbox.h> +#include <kdialog.h> +#include <kglobalsettings.h> +#include <klocale.h> +#include <kprocess.h> +#include <kstdguiitem.h> +#include <kdeversion.h> + +#include <qframe.h> +#include <qlabel.h> +#include <qlayout.h> +#include <qlistbox.h> +#include <qtoolbutton.h> +#include <qpushbutton.h> + +#include <stdlib.h> +#include <unistd.h> +#include <sys/types.h> + +namespace RDBDebugger +{ + +/***************************************************************************/ + +// Display a list of processes for the user to select one +// only display processes that they can do something with so if the user +// is root then display all processes +// For use with the internal debugger, but this dialog doesn't know anything +// about why it's doing it. + +Dbg_PS_Dialog::Dbg_PS_Dialog(QWidget *parent, const char *name) + : KDialog(parent, name, true), // modal + psProc_(0), + pids_(new QListBox(this)), + heading_(new QLabel(" ", this)), + pidLines_(QString()) +{ + setCaption(i18n("Attach to Process")); + + QBoxLayout *topLayout = new QVBoxLayout(this, 5); + + heading_->setFont(KGlobalSettings::fixedFont()); + heading_->setFrameStyle(QFrame::Panel|QFrame::Sunken); + heading_->setMaximumHeight(heading_->sizeHint().height()); +// heading_->setMinimumSize(heading_->sizeHint()); + topLayout->addWidget(heading_, 5); + + topLayout->addWidget(pids_, 5); + pids_->setFont(KGlobalSettings::fixedFont()); + + KButtonBox *buttonbox = new KButtonBox(this, Qt::Horizontal, 5); + QPushButton *ok = buttonbox->addButton(KStdGuiItem::ok()); + buttonbox->addStretch(); + QPushButton *cancel = buttonbox->addButton(KStdGuiItem::cancel()); + buttonbox->layout(); + topLayout->addWidget(buttonbox); + + connect(ok, SIGNAL(clicked()), SLOT(accept())); + connect(cancel, SIGNAL(clicked()), SLOT(reject())); + + psProc_ = new KShellProcess("/bin/sh"); + #ifdef USE_SOLARIS + *psProc_ << "ps"; + *psProc_ << "-opid"; + *psProc_ << "-otty"; + *psProc_ << "-os"; + *psProc_ << "-otime"; + *psProc_ << "-oargs"; + pidCmd_ = "ps -opid -otty -os -otime -oargs"; + + if (getuid() == 0) { + *psProc_ << "-e"; + pidCmd_ += " -e"; + } + #else + *psProc_ << "ps"; + *psProc_ << "x"; + pidCmd_ = "ps x"; + + if (getuid() == 0) { + *psProc_ << "a"; + pidCmd_ += " a"; + } + #endif + + connect( psProc_, SIGNAL(processExited(KProcess *)), SLOT(slotProcessExited()) ); + connect( psProc_, SIGNAL(receivedStdout(KProcess *, char *, int)), SLOT(slotReceivedOutput(KProcess *, char *, int)) ); + psProc_->start(KProcess::NotifyOnExit, KProcess::Stdout); + + // Default display to 40 chars wide, default height is okay + resize( ((KGlobalSettings::fixedFont()).pointSize())*40, height()); + topLayout->activate(); +} + +/***************************************************************************/ + +Dbg_PS_Dialog::~Dbg_PS_Dialog() +{ + delete psProc_; +} + +/***************************************************************************/ + +int Dbg_PS_Dialog::pidSelected() +{ + QString pidText = pids_->text(pids_->currentItem()); + if (!pidText.isEmpty()) + return atoi(pidText.latin1()); + + return 0; +} + +/***************************************************************************/ + +void Dbg_PS_Dialog::slotReceivedOutput(KProcess */*proc*/, char *buffer, int buflen) +{ + pidLines_ += QString::fromLocal8Bit(buffer, buflen+1); +} + +/***************************************************************************/ + +void Dbg_PS_Dialog::slotProcessExited() +{ + delete psProc_; + psProc_ = 0; + + pidLines_ += '\n'; + + int start = pidLines_.find('\n', 0); // Skip the first line (header line) + int pos; + if (start != -1) + heading_->setText(pidLines_.left(start)); + while ( (pos = pidLines_.find('\n', start)) != -1) { + QString item = pidLines_.mid(start, pos-start); + if (!item.isEmpty()) { + if (item.find(pidCmd_) == -1) + pids_->insertItem(item); + } + + start = pos+1; + } +} + +} + +/***************************************************************************/ +#include "dbgpsdlg.moc" diff --git a/languages/ruby/debugger/dbgpsdlg.h b/languages/ruby/debugger/dbgpsdlg.h new file mode 100644 index 00000000..641f7aa5 --- /dev/null +++ b/languages/ruby/debugger/dbgpsdlg.h @@ -0,0 +1,60 @@ +/*************************************************************************** + begin : Mon Sep 20 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. * + * * + ***************************************************************************/ + +#ifndef _DBGPSDLG_H_ +#define _DBGPSDLG_H_ + +#include <kdialog.h> + +class QListBox; +class KProcess; +class QLabel; + +namespace RDBDebugger +{ + +/***************************************************************************/ + +class Dbg_PS_Dialog : public KDialog +{ + Q_OBJECT + +public: + Dbg_PS_Dialog( QWidget *parent=0, const char *name=0 ); + ~Dbg_PS_Dialog(); + + int pidSelected(); + +private slots: + void slotReceivedOutput(KProcess *proc, char *buffer, int buflen); + void slotProcessExited(); + +private: + KProcess* psProc_; + QListBox* pids_; + QLabel* heading_; + QString pidLines_; + QString pidCmd_; +}; + +} + +#endif diff --git a/languages/ruby/debugger/dbgtoolbar.cpp b/languages/ruby/debugger/dbgtoolbar.cpp new file mode 100644 index 00000000..702c8e83 --- /dev/null +++ b/languages/ruby/debugger/dbgtoolbar.cpp @@ -0,0 +1,483 @@ +/*************************************************************************** + begin : Thu Dec 23 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 "dbgtoolbar.h" +#include "debuggerpart.h" +#include "dbgcontroller.h" + +#include <kdockwindow.h> +#include <kiconloader.h> +#include <klocale.h> +#include <kpopupmenu.h> +#include <kstandarddirs.h> +#include <kwin.h> +#include <kwinmodule.h> + +#include <qapplication.h> +#include <qcursor.h> +#include <qframe.h> +#include <qlayout.h> +#include <qpainter.h> +#include <qpushbutton.h> +#include <qtooltip.h> +#include <qwhatsthis.h> + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +// Implements a floating toolbar for the debugger. + +// Unfortunately, I couldn't get the KToolBar to work nicely when it +// was floating, so I was forced to write these classes. I'm not sure whether +// I didn't try hard enough or ... and I've forgotten what the problems were +// now. + +// The problem with using this is that it will not dock as a normal toolbar. +// I'm not convince that this is a real problem though. + +// So, if you can get it to work as a KToolBar, and it works well when the +// app is running, then all these classes can be removed. + +// This code is very specific to the internal debugger in kdevelop. + +namespace RDBDebugger +{ + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +// This just allows the user to click on the toolbar and drag it somewhere else. +// I would have preferred to use normal decoration on the toolbar and removed +// the iconify, close, etc buttons from the window title but again I kept running +// into problems. Instead, I used no decoration and this class. Also this looks +// similar to the KToolBar floating style. +class DbgMoveHandle : public QFrame +{ +public: + DbgMoveHandle(DbgToolBar *parent=0, const char * name=0, WFlags f=0); + virtual ~DbgMoveHandle(); + + virtual void mousePressEvent(QMouseEvent *e); + virtual void mouseReleaseEvent(QMouseEvent *e); + virtual void mouseMoveEvent(QMouseEvent *e); + +private: + DbgToolBar* toolBar_; + QPoint offset_; + bool moving_; +}; + +// ************************************************************************** + +DbgMoveHandle::DbgMoveHandle(DbgToolBar *parent, const char * name, WFlags f) + : QFrame(parent, name, f), + toolBar_(parent), + offset_(QPoint(0,0)), + moving_(false) +{ + setFrameStyle(QFrame::Panel|QFrame::Raised); + setFixedHeight(12); +} + +// ************************************************************************** + +DbgMoveHandle::~DbgMoveHandle() +{ +} + +// ************************************************************************** + +void DbgMoveHandle::mousePressEvent(QMouseEvent *e) +{ + QFrame::mousePressEvent(e); + if (moving_) + return; + + if (e->button() == RightButton) { + KPopupMenu *menu = new KPopupMenu(this); + menu->insertTitle(i18n("Debug Toolbar")); + menu->insertItem(i18n("Dock to Panel"), + parent(), SLOT(slotDock())); + menu->insertItem(i18n("Dock to Panel && Iconify KDevelop"), + parent(), SLOT(slotIconifyAndDock())); + menu->popup(e->globalPos()); + } else { + moving_ = true; + offset_ = parentWidget()->pos() - e->globalPos(); + setFrameStyle(QFrame::Panel|QFrame::Sunken); + QApplication::setOverrideCursor(QCursor(sizeAllCursor)); + setPalette(QPalette(colorGroup().background())); + repaint(); + } +} + +// ************************************************************************** + +void DbgMoveHandle::mouseReleaseEvent(QMouseEvent *e) +{ + QFrame::mouseReleaseEvent(e); + moving_ = false; + offset_ = QPoint(0,0); + setFrameStyle(QFrame::Panel|QFrame::Raised); + QApplication::restoreOverrideCursor(); + setPalette(QPalette(colorGroup().background())); + repaint(); +} + +// ************************************************************************** + +void DbgMoveHandle::mouseMoveEvent(QMouseEvent *e) +{ + QFrame::mouseMoveEvent(e); + if (!moving_) + return; + + toolBar_->move(e->globalPos() + offset_); +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +// This class adds text _and_ a pixmap to a button. Why doesn't QPushButton +// support that? It only allowed text _or_ pixmap. +class DbgButton : public QPushButton +{ +public: + DbgButton(const QPixmap &pixmap, const QString &text, + DbgToolBar *parent, const char *name=0); + virtual ~DbgButton() {}; + void drawButtonLabel(QPainter *painter); + QSize sizeHint() const; + +private: + QPixmap pixmap_; +}; + +// ************************************************************************** + +DbgButton::DbgButton(const QPixmap& pixmap, const QString& text, + DbgToolBar* parent, const char* name) + : QPushButton(parent, name), + pixmap_(pixmap) +{ + setText(text); +} + +// ************************************************************************** + +void DbgButton::drawButtonLabel(QPainter *painter) +{ + // We always have a pixmap (today...) + // Centre it if there's no text + + bool hasText = !text().isEmpty(); + int x = ((hasText ? height() : width()) - pixmap_.width()) / 2; + int y = (height() - pixmap_.height()) / 2; + painter->drawPixmap(x, y, pixmap_); + + if (hasText) { + painter->setPen(colorGroup().text()); + painter->drawText(height()+2, 0, width()-(height()+2), height(), AlignLeft|AlignVCenter, text()); + } +} + +// ************************************************************************** + +QSize DbgButton::sizeHint() const +{ + if (text().isEmpty()) + return pixmap_.size(); + else + return QPushButton::sizeHint(); +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +DbgDocker::DbgDocker(QWidget* parent, DbgToolBar* toolBar, const QPixmap& pixmap) : + KSystemTray(parent, "DbgDocker"), + toolBar_(toolBar) +{ + setPixmap(pixmap); + QToolTip::add( this, i18n("KDevelop ruby debugger: Click to execute one line of code (\"step\")") ); +} + +// ************************************************************************** + +void DbgDocker::mousePressEvent(QMouseEvent *e) +{ + if (!rect().contains( e->pos())) + return; + + switch (e->button()) { + case LeftButton: + { + // Not really a click, but it'll hold for the time being !!! + emit clicked(); + break; + } + case RightButton: + { + KPopupMenu* menu = new KPopupMenu(this); + menu->insertTitle(i18n("Debug Toolbar")); + menu->insertItem(i18n("Activate"), toolBar_, SLOT(slotUndock())); + menu->insertItem(i18n("Activate (KDevelop gets focus)"), toolBar_, SLOT(slotActivateAndUndock())); + menu->popup(e->globalPos()); + break; + } + default: + break; + } +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +DbgToolBar::DbgToolBar(RubyDebuggerPart* part, + QWidget* parent, const char* name) + : QFrame(0, name), + part_(part), + activeWindow_(0), + winModule_(0), + bKDevFocus_(0), + bPrevFocus_(0), + appIsActive_(false), + docked_(false), + docker_(0), + dockWindow_(new KSystemTray(parent)) +{ + winModule_ = new KWinModule(this); + docker_ = new DbgDocker(parent, this, BarIcon("dbgnext")); + connect(docker_, SIGNAL(clicked()), part_, SLOT(slotStepOver())); + + // Must have noFocus set so that we can see what window was active. + // see slotDbgKdevFocus() for more comments + // I do not want the user to be able to "close" this widget. If we have any + // decoration then they can and that is bad. + // This widget is closed when the debugger finishes i.e. they press "Stop" + + // Do we need NoFocus??? + KWin::setState(winId(), NET::StaysOnTop | NET::Modal | NET::SkipTaskbar); +// KWin::setType(winId(), NET::Override); // So it has no decoration + KWin::setType(winId(), NET::Dock); + + setFocusPolicy(NoFocus); + setFrameStyle( QFrame::Box | QFrame::Plain ); + setLineWidth(4); + setMidLineWidth(0); + + QBoxLayout* topLayout = new QVBoxLayout(this); + + QBoxLayout* nextLayout = new QHBoxLayout(); + QBoxLayout* stepLayout = new QHBoxLayout(); + QBoxLayout* focusLayout = new QHBoxLayout(); + + DbgMoveHandle* moveHandle= new DbgMoveHandle(this); + + QPushButton* bRun = new DbgButton(BarIcon("dbgrun"), i18n("Run"), this); + QPushButton* bInterrupt = new DbgButton(BarIcon("player_pause"), i18n("Interrupt"), this); + QPushButton* bNext = new DbgButton(BarIcon("dbgnext"), i18n("Step Over"), this); + QPushButton* bStep = new DbgButton(BarIcon("dbgstep"), i18n("Step Into"), this); + QPushButton* bFinish = new DbgButton(BarIcon("dbgstepout"), i18n("Step Out"), this); + QPushButton* bRunTo = new DbgButton(BarIcon("dbgrunto"), i18n("Run to Cursor"), this); + bPrevFocus_ = new DbgButton(BarIcon("dbgmemview"), QString::null, this); + bKDevFocus_ = new DbgButton(BarIcon("kdevelop"), QString::null, this); + + connect(bRun, SIGNAL(clicked()), part_, SLOT(slotRun())); + connect(bInterrupt, SIGNAL(clicked()), part_, SLOT(slotPause())); + connect(bNext, SIGNAL(clicked()), part_, SLOT(slotStepOver())); + connect(bStep, SIGNAL(clicked()), part_, SLOT(slotStepInto())); + connect(bFinish, SIGNAL(clicked()), part_, SLOT(slotStepOut())); + connect(bRunTo, SIGNAL(clicked()), part_, SLOT(slotRunToCursor())); + connect(bKDevFocus_, SIGNAL(clicked()), this, SLOT(slotKdevFocus())); + connect(bPrevFocus_, SIGNAL(clicked()), this, SLOT(slotPrevFocus())); + + QToolTip::add( bRun, i18n("Continue with application execution, may start the application") ); + QToolTip::add( bInterrupt, i18n("Interrupt the application execution") ); + QToolTip::add( bNext, i18n("Execute one line of code, but run through methods") ); + QToolTip::add( bStep, i18n("Execute one line of code, stepping into methods if appropriate") ); + QToolTip::add( bFinish, i18n("Execute to end of current stack frame") ); + QToolTip::add( bRunTo, i18n("Continues execution until the cursor position is reached.") ); + QToolTip::add( bKDevFocus_, i18n("Set focus on KDevelop") ); + QToolTip::add( bPrevFocus_, i18n("Set focus on window that had focus when KDevelop got focus") ); + + QWhatsThis::add( bRun, i18n("Continue with application execution. May start the application.") ); + QWhatsThis::add( bInterrupt, i18n("Interrupt the application execution.") ); + QWhatsThis::add( bNext, i18n("Execute one line of code, but run through methods.") ); + + QWhatsThis::add( bStep, i18n("Execute one line of code, stepping into methods if appropriate.") ); + + QWhatsThis::add( bFinish, i18n("Execute to end of current stack frame.") ); + QWhatsThis::add( bRunTo, i18n("Continues execution until the cursor position is reached.") ); + QWhatsThis::add( bKDevFocus_, i18n("Set focus on KDevelop.") ); + QWhatsThis::add( bPrevFocus_, i18n("Set focus on window that had focus when KDevelop got focus.") ); + + topLayout->addWidget(moveHandle); + topLayout->addWidget(bRun); + topLayout->addLayout(nextLayout); + topLayout->addLayout(stepLayout); + topLayout->addWidget(bFinish); + topLayout->addWidget(bRunTo); + topLayout->addWidget(bInterrupt); + topLayout->addLayout(focusLayout); + + focusLayout->addWidget(bKDevFocus_); + focusLayout->addWidget(bPrevFocus_); + + stepLayout->addWidget(bStep); + + nextLayout->addWidget(bNext); + +// int w = QMAX(bRun->sizeHint().width(), bFinish->sizeHint().width()); +// w = QMAX(w, bInterrupt->sizeHint().width()); +// w = QMAX(w, bView->sizeHint().width()); + + // they should have the same height, so don't be too fussy +// int h = bFinish->sizeHint().height(); +// +// bNext->setMinimumHeight(h); +// bNexti->setMinimumHeight(h); +// bStep->setMinimumHeight(h); +// bStepi->setMinimumHeight(h); +// bKDevFocus_->setMinimumHeight(h); +// bPrevFocus_->setMinimumHeight(h); + +// setMinimumSize(w+10, h*7); +// setMaximumSize(w+10, h*7); + + setAppIndicator(appIsActive_); + topLayout->activate(); +} + +// ************************************************************************** + +DbgToolBar::~DbgToolBar() +{ + slotUndock(); +} + +// ************************************************************************** + +void DbgToolBar::slotKdevFocus() +{ + // I really want to be able to set the focus on the _application_ being debugged + // but this is the best compromise I can come up with. All we do is save the + // window that had focus when they switch to the kdevelop window. To do this + // the toolbar _cannot_ accept focus. + // If anyone has a way of determining what window the app is _actually_ running on + // then please fix and send a patch. + + if (winModule_->activeWindow() != topLevelWidget()->winId()) + activeWindow_ = winModule_->activeWindow(); + + KWin::activateWindow(topLevelWidget()->winId()); +} + +// ************************************************************************** + +void DbgToolBar::slotPrevFocus() +{ + KWin::activateWindow(activeWindow_); +} + +// ************************************************************************** + +// If the app is active then the app button is highlighted, otherwise +// kdev button is highlighted. +void DbgToolBar::slotDbgStatus(const QString&, int state) +{ + bool appIndicator = state & s_appBusy; + if (appIndicator != appIsActive_) { + setAppIndicator(appIndicator); + appIsActive_ = appIndicator; + } +} + +// ************************************************************************** + +void DbgToolBar::setAppIndicator(bool appIndicator) +{ + if (appIndicator) { + bPrevFocus_->setPalette(QPalette(colorGroup().mid())); + bKDevFocus_->setPalette(QPalette(colorGroup().background())); + } else { + bPrevFocus_->setPalette(QPalette(colorGroup().background())); + bKDevFocus_->setPalette(QPalette(colorGroup().mid())); + } +} + +// ************************************************************************** + +void DbgToolBar::slotDock() +{ + if (docked_) + return; + + // Q_ASSERT(!docker_); + hide(); + + docker_->show(); + docked_ = true; +} + +// ************************************************************************** + +void DbgToolBar::slotIconifyAndDock() +{ + if (docked_) + return; + + // KWin::iconifyWindow(ckDevelop_->winId(), true); + slotDock(); +} + +// ************************************************************************** + +void DbgToolBar::slotUndock() +{ + if (!docked_) + return; + + show(); + docker_->hide(); + docked_ = false; +} + +// ************************************************************************** + +void DbgToolBar::slotActivateAndUndock() +{ + if (!docked_) + return; + + KWin::activateWindow(topLevelWidget()->winId()); + slotUndock(); +} + +} + +// ************************************************************************** +#include "dbgtoolbar.moc" diff --git a/languages/ruby/debugger/dbgtoolbar.h b/languages/ruby/debugger/dbgtoolbar.h new file mode 100644 index 00000000..a19b2eae --- /dev/null +++ b/languages/ruby/debugger/dbgtoolbar.h @@ -0,0 +1,90 @@ +/*************************************************************************** + begin : Thu Dec 23 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 *q + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#ifndef _DBGTOOLBAR_H_ +#define _DBGTOOLBAR_H_ + +class KWinModule; + +#include <ksystemtray.h> +#include <kwin.h> // needed for WId :( + +#include <qframe.h> + +namespace RDBDebugger +{ + +class DbgButton; +class DbgToolBar; +class RubyDebuggerPart; + +class DbgDocker : public KSystemTray +{ + Q_OBJECT + +public: + DbgDocker(QWidget *parent, DbgToolBar *toolBar, const QPixmap &pixmap); + virtual ~DbgDocker() {}; + virtual void mousePressEvent(QMouseEvent *e); + +signals: + void clicked(); + +private: + DbgToolBar* toolBar_; +}; + + +class DbgToolBar : public QFrame +{ + Q_OBJECT + +public: + DbgToolBar(RubyDebuggerPart *part, QWidget* parent, const char* name=0); + virtual ~DbgToolBar(); + +private slots: + void slotDbgStatus(const QString&, int); + void slotDock(); + void slotUndock(); + void slotIconifyAndDock(); + void slotActivateAndUndock(); + + void slotKdevFocus(); + void slotPrevFocus(); + +private: + void setAppIndicator(bool appIndicator); + + RubyDebuggerPart* part_; + WId activeWindow_; + KWinModule* winModule_; + DbgButton* bKDevFocus_; + DbgButton* bPrevFocus_; + bool appIsActive_; + bool docked_; + DbgDocker* docker_; + KSystemTray* dockWindow_; +}; + +} + +#endif diff --git a/languages/ruby/debugger/debuggee.rb b/languages/ruby/debugger/debuggee.rb new file mode 100644 index 00000000..38e2dea7 --- /dev/null +++ b/languages/ruby/debugger/debuggee.rb @@ -0,0 +1,1214 @@ +# Copyright (C) 2000 Network Applied Communication Laboratory, Inc. +# Copyright (C) 2000 Information-technology Promotion Agency, Japan +# Copyright (C) 2000-2003 NAKAMURA, Hiroshi <nahi@ruby-lang.org> + +# Changes for the FreeRIDE IDE by Laurent JULLIARD. FreeRIDE uses +# Distributed ruby (DRuby) to communicate with the debugger back +# end. However, this can't interoperate with C++ in KDevelop and so +# a Unix domain socket connection is used instead. + +# Adapted for KDevelop debugging +# ------------------------------ +# begin : Mon Nov 1 2004 +# copyright : (C) 2004 by Richard Dale +# email : Richard_Dale@tipitina.demon.co.uk + +if $SAFE > 0 + STDERR.print "-r debug.rb is not available in safe mode\n" + exit 1 +end + +require 'tracer' +require 'pp' +require 'rbconfig' + +class Tracer + def Tracer.trace_func(*vars) + Single.trace_func(*vars) + end +end + +# FreeRIDE/KDevelop must always intercept exits hence the exit! redefinition +# at_exit calls the quit method to cleanly disconnect from the +# FreeRIDE/KDevelop debugger client +module Kernel + alias_method :exit!, :exit +end + +BEGIN { + at_exit do + set_trace_func nil + DEBUGGER__.quit + end +} + +SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__ + +class DEBUGGER__ +class Mutex + def initialize + @locker = nil + @waiting = [] + @locked = false; + end + + def locked? + @locked + end + + def lock + return if Thread.critical + return if @locker == Thread.current + while (Thread.critical = true; @locked) + @waiting.push Thread.current + Thread.stop + end + @locked = true + @locker = Thread.current + Thread.critical = false + self + end + + def unlock + return if Thread.critical + return unless @locked + unless @locker == Thread.current + raise RuntimeError, "unlocked by other" + end + Thread.critical = true + t = @waiting.shift + @locked = false + @locker = nil + Thread.critical = false + t.run if t + self + end +end +MUTEX = Mutex.new + +class Context + DEBUG_LAST_CMD = [] + + def readline(prompt_cmd, hist) + DEBUGGER__.client.readline(prompt_cmd) + end + + def initialize + if Thread.current == Thread.main + @stop_next = 1 + else + @stop_next = 0 + end + @last_file = nil + @file = nil + @line = nil + @no_step = nil + @frames = [] + @finish_pos = 0 + @trace = false + @trace_ruby = false + @catch = "StandardError" + @suspend_next = false + end + + def stop_next(n=1) + @stop_next = n + end + + def set_suspend + @suspend_next = true + end + + def clear_suspend + @suspend_next = false + end + + def suspend_all + DEBUGGER__.suspend + end + + def resume_all + DEBUGGER__.resume + end + + def check_suspend + return if Thread.critical + while (Thread.critical = true; @suspend_next) + DEBUGGER__.waiting.push Thread.current + @suspend_next = false + Thread.stop + end + Thread.critical = false + end + + def trace? + @trace + end + + def set_trace(arg) + @trace = arg + end + + def trace_ruby? + @trace_ruby + end + + def set_trace_ruby(arg) + @trace_ruby = arg + end + + def stdout + DEBUGGER__.stdout + end + + def break_points + DEBUGGER__.break_points + end + + def display + DEBUGGER__.display + end + + def context(th) + DEBUGGER__.context(th) + end + + def set_trace_all(arg) + DEBUGGER__.set_trace(arg) + end + + def set_last_thread(th) + DEBUGGER__.set_last_thread(th) + end + + def debug_eval(str, binding) + begin + val = eval(str, binding) + rescue StandardError, ScriptError => e + at = eval("caller(1)", binding) + stdout.printf "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '') + for i in at + stdout.printf "\tfrom %s\n", i + end + throw :debug_error + end + end + + def debug_silent_eval(str, binding) + begin + eval(str, binding) + rescue StandardError, ScriptError + nil + end + end + + # Temporarily change the pretty_print methods to not expand arrays + # and hashes, just give the length + def customize_debug_pp + Array.module_eval %q{ + def pretty_print(pp) + pp.pp "Array (%d element(s))" % length + end + } + + Hash.module_eval %q{ + def pretty_print(pp) + pp.pp "Hash (%d element(s))" % length + end + } + end + + # Restore the original pretty_print methods for arrays and hashes + def restore_debug_pp + Array.module_eval %q{ + def pretty_print(q) + q.group(1, '[', ']') { + self.each {|v| + q.comma_breakable unless q.first? + q.pp v + } + } + end + } + Hash.module_eval %q{ + def pretty_print(q) + q.pp_hash self + end + } + end + + # Prevent the 'var *' commands from expanding Arrays and Hashes + # This could be done by redefining inspect, but that would affect + # everywhere not just here and in the pp command. + def debug_inspect(obj) + if obj.kind_of? Array + "Array (%d element(s))" % obj.length + elsif obj.kind_of? Hash + "Hash (%d element(s))" % obj.length + elsif obj.kind_of? String + str = obj.inspect + if str.length > 255 + "String (length %d)" % obj.length + else + str + end + else + obj.inspect + end + end + + def var_list(ary, binding) + ary.sort! + for v in ary + stdout.printf " %s => %s\n", v, debug_inspect(eval(v, binding)) + end + end + + def const_list(ary, obj) + ary.sort! + for c in ary + str = debug_inspect(obj.module_eval(c)) + if c.to_s != str && + str !~ /^Qt::|^KDE::/ && c.to_s !~ /@@classes$|@@cpp_names$|@@idclass$|@@debug_level$/ && + c.to_s !~ /^DCOPMeta$|^Meta$|SCRIPT_LINES__|TRUE|FALSE|NIL|MatchingData/ && + c.to_s !~ /^PLATFORM$|^RELEASE_DATE$|^VERSION$|SilentClient|SilentObject/ && + c.to_s !~ /^Client$|^Context$|^DEBUG_LAST_CMD$|^MUTEX$|^Mutex$|^SimpleDelegater$|^Delegater$/ && + c.to_s !~ /IPsocket|IPserver|UDPsocket|UDPserver|TCPserver|TCPsocket|UNIXserver|UNIXsocket/ + if c.to_s == "ENV" + stdout.printf " %s => Hash (%d element(s))\n", c, obj.module_eval(c).length + else + stdout.printf " %s => %s\n", c, str + end + end + end + end + + def debug_variable_info(input, binding) + case input + when /^\s*g(?:lobal)?$/ + var_list(global_variables, binding) + + when /^\s*l(?:ocal)?$/ + var_list(eval("local_variables", binding) << "self", binding) + + when /^\s*i(?:nstance)?\s+/ + obj = debug_eval($', binding) + var_list(obj.instance_variables, obj.instance_eval{binding()}) + + when /^\s*cl(?:ass)?\s+/ + obj = debug_eval($', binding) + unless obj.kind_of? Module + stdout.print "Should be Class/Module: ", $', "\n" + else + const_list(obj.class_variables, obj) + end + + when /^\s*c(?:onst(?:ant)?)?\s+/ + obj = debug_eval($', binding) + unless obj.kind_of? Module + stdout.print "Should be Class/Module: ", $', "\n" + else + const_list(obj.constants, obj) + end + end + end + + def debug_method_info(input, binding) + case input + when /^i(:?nstance)?\s+/ + obj = debug_eval($', binding) + + len = 0 + for v in obj.methods.sort + len += v.size + 1 + if len > 70 + len = v.size + 1 + stdout.print "\n" + end + stdout.print v, " " + end + stdout.print "\n" + + else + obj = debug_eval(input, binding) + unless obj.kind_of? Module + stdout.print "Should be Class/Module: ", input, "\n" + else + len = 0 + for v in obj.instance_methods(false).sort + len += v.size + 1 + if len > 70 + len = v.size + 1 + stdout.print "\n" + end + stdout.print v, " " + end + stdout.print "\n" + end + end + end + + def thnum + num = DEBUGGER__.instance_eval{@thread_list[Thread.current]} + unless num + DEBUGGER__.make_thread_list + num = DEBUGGER__.instance_eval{@thread_list[Thread.current]} + end + num + end + + def debug_command(file, line, id, binding) + MUTEX.lock + set_last_thread(Thread.current) + frame_pos = 0 + binding_file = file + binding_line = line + previous_line = nil + if ENV['EMACS'] + stdout.printf "\032\032%s:%d:\n", binding_file, binding_line + else + stdout.printf "%s:%d:%s", binding_file, binding_line, + line_at(binding_file, binding_line) + end + @frames[0] = [binding, file, line, id] + display_expressions(binding) + prompt = true + while prompt and input = readline("(rdb:%d) "%thnum(), true) + catch(:debug_error) do + if input == "" + next unless DEBUG_LAST_CMD[0] + input = DEBUG_LAST_CMD[0] + stdout.print input, "\n" + else + DEBUG_LAST_CMD[0] = input + end + + case input + when /^\s*trace_ruby(?:\s+(on|off))?$/ + if defined?( $1 ) + if $1 == 'on' + set_trace_ruby true + else + set_trace_ruby false + end + end + + when /^\s*tr(?:ace)?(?:\s+(on|off))?(?:\s+(all))?$/ + if defined?( $2 ) + if $1 == 'on' + set_trace_all true + else + set_trace_all false + end + elsif defined?( $1 ) + if $1 == 'on' + set_trace true + else + set_trace false + end + end + if trace? + stdout.print "Trace on.\n" + else + stdout.print "Trace off.\n" + end + + when /^\s*b(?:reak)?\s+(?:(.+):)?([^.:]+)$/ + pos = $2 + if $1 + klass = debug_silent_eval($1, binding) +# file = $1 + file = File.expand_path($1) + end + if pos =~ /^\d+$/ + pname = pos + pos = pos.to_i + else + pname = pos = pos.intern.id2name + end + break_points.push [true, 0, klass || file, pos] + stdout.printf "Set breakpoint %d at %s:%s\n", break_points.size, klass || file, pname + + when /^\s*b(?:reak)?\s+(.+)[#.]([^.:]+)$/ + pos = $2.intern.id2name + klass = debug_eval($1, binding) + break_points.push [true, 0, klass, pos] + stdout.printf "Set breakpoint %d at %s.%s\n", break_points.size, klass, pos + + when /^\s*wat(?:ch)?\s+(.+)$/ + exp = $1 + break_points.push [true, 1, exp] + stdout.printf "Set watchpoint %d\n", break_points.size, exp + + when /^\s*b(?:reak)?$/ + if break_points.find{|b| b[1] == 0} + n = 1 + stdout.print "Breakpoints:\n" + for b in break_points + if b[0] and b[1] == 0 + stdout.printf " %d %s:%s\n", n, b[2], b[3] + end + n += 1 + end + end + if break_points.find{|b| b[1] == 1} + n = 1 + stdout.print "\n" + stdout.print "Watchpoints:\n" + for b in break_points + if b[0] and b[1] == 1 + stdout.printf " %d %s\n", n, b[2] + end + n += 1 + end + end + if break_points.size == 0 + stdout.print "No breakpoints\n" + else + stdout.print "\n" + end + + when /^\s*del(?:ete)?(?:\s+(\d+))?$/ + pos = $1 + unless pos +# input = readline("Clear all breakpoints? (y/n) ", false) +# if input == "y" + for b in break_points + b[0] = false + end +# end + else + pos = pos.to_i + if break_points[pos-1] + break_points[pos-1][0] = false + else + stdout.printf "Breakpoint %d is not defined\n", pos + end + end + + when /^\s*disp(?:lay)?\s+(.+)$/ + exp = $1 + display.push [true, exp] + stdout.printf "%d: ", display.size + display_expression(exp, binding) + + when /^\s*disp(?:lay)?$/ + display_expressions(binding) + + when /^\s*undisp(?:lay)?(?:\s+(\d+))?$/ + pos = $1 + unless pos +# input = readline("Clear all expressions? (y/n) ", false) +# if input == "y" + for d in display + d[0] = false + end +# end + else + pos = pos.to_i + if display[pos-1] + display[pos-1][0] = false + else + stdout.printf "Display expression %d is not defined\n", pos + end + end + + when /^\s*c(?:ont)?$/ + prompt = false + + when /^\s*s(?:tep)?(?:\s+(\d+))?$/ + if $1 + lev = $1.to_i + else + lev = 1 + end + @stop_next = lev + prompt = false + + when /^\s*n(?:ext)?(?:\s+(\d+))?$/ + if $1 + lev = $1.to_i + else + lev = 1 + end + @stop_next = lev + @no_step = @frames.size - frame_pos + prompt = false + + when /^\s*w(?:here)?$/, /^\s*f(?:rame)?$/ + display_frames(frame_pos) + + when /^\s*l(?:ist)?(?:\s+(.+))?$/ + if not $1 + b = previous_line ? previous_line + 10 : binding_line - 5 + e = b + 9 + elsif $1 == '-' + b = previous_line ? previous_line - 10 : binding_line - 5 + e = b + 9 + else + b, e = $1.split(/[-,]/) + if e + b = b.to_i + e = e.to_i + else + b = b.to_i - 5 + e = b + 9 + end + end + previous_line = b + display_list(b, e, binding_file, binding_line) + + when /^\s*up(?:\s+(\d+))?$/ + previous_line = nil + if $1 + lev = $1.to_i + else + lev = 1 + end + frame_pos += lev + if frame_pos >= @frames.size + frame_pos = @frames.size - 1 + stdout.print "At toplevel\n" + end + binding, binding_file, binding_line = @frames[frame_pos] + stdout.print format_frame(frame_pos) + + when /^\s*down(?:\s+(\d+))?$/ + previous_line = nil + if $1 + lev = $1.to_i + else + lev = 1 + end + frame_pos -= lev + if frame_pos < 0 + frame_pos = 0 + stdout.print "At stack bottom\n" + end + binding, binding_file, binding_line = @frames[frame_pos] + stdout.print format_frame(frame_pos) + + when /^\s*fin(?:ish)?$/ + if frame_pos == @frames.size + stdout.print "\"finish\" not meaningful in the outermost frame.\n" + else + @finish_pos = @frames.size - frame_pos + frame_pos = 0 + prompt = false + end + + when /^\s*cat(?:ch)?(?:\s+(.+))?$/ + if $1 + excn = $1 + if excn == 'off' + @catch = nil + stdout.print "Clear catchpoint.\n" + else + @catch = excn + stdout.printf "Set catchpoint %s.\n", @catch + end + else + if @catch + stdout.printf "Catchpoint %s.\n", @catch + else + stdout.print "No catchpoint.\n" + end + end + + when /^\s*q(?:uit)?$/ +# input = readline("Really quit? (y/n) ", false) +# if input == "y" + exit! # exit -> exit!: No graceful way to stop threads... +# end + + + when /^\s*v(?:ar)?\s+/ + debug_variable_info($', binding) + + when /^\s*m(?:ethod)?\s+/ + debug_method_info($', binding) + + when /^\s*th(?:read)?\s+/ + if DEBUGGER__.debug_thread_info($', binding) == :cont + prompt = false + end + + when /^\s*pp\s+/ + obj_name = $' + obj = debug_eval($', binding) + customize_debug_pp + if obj.kind_of? Array + obj.each_index { |i| stdout.printf "[%d]=%s\n", i.to_s, debug_inspect(obj[i]) } + elsif obj.kind_of? Hash or obj_name =~ /^ENV$/ + # Special case ENV to print like a hash + obj.each { |key, value| stdout.printf "[%s]=%s\n", key.inspect, debug_inspect(value) } + elsif obj.kind_of?(String) && obj.inspect.length > 255 + # Assume long strings contain packed data and show them as a + # sequence of 12 byte slices in hex + i = 0 + while i < obj.length + j = (i + 12 < obj.length ? i + 12 : obj.length) - 1 + stdout.printf "[%d..%d]=0x", i, j + for k in i..j + stdout.printf "%2.2x", obj[k] + end + stdout.printf " %s\n", obj[i..j].dump + + i += 12 + end + else + PP.pp(obj, stdout) + end + restore_debug_pp + + when /^\s*p\s+/ + stdout.printf "%s\n", debug_eval($', binding).inspect + + when /^\s*h(?:elp)?$/ + debug_print_help() + + else + v = debug_eval(input, binding) + stdout.printf "%s\n", v.inspect + end + end + end + MUTEX.unlock + resume_all + end + + def debug_print_help + stdout.print <<EOHELP +Debugger help v.-0.002b +Commands + b[reak] [file|class:]<line|method> + b[reak] [class.]<line|method> + set breakpoint to some position + wat[ch] <expression> set watchpoint to some expression + cat[ch] <an Exception> set catchpoint to an exception + b[reak] list breakpoints + cat[ch] show catchpoint + del[ete][ nnn] delete some or all breakpoints + disp[lay] <expression> add expression into display expression list + undisp[lay][ nnn] delete one particular or all display expressions + c[ont] run until program ends or hit breakpoint + s[tep][ nnn] step (into methods) one line or till line nnn + n[ext][ nnn] go over one line or till line nnn + w[here] display frames + f[rame] alias for where + l[ist][ (-|nn-mm)] list program, - lists backwards + nn-mm lists given lines + up[ nn] move to higher frame + down[ nn] move to lower frame + fin[ish] return to outer frame + tr[ace] (on|off) set trace mode of current thread + tr[ace] (on|off) all set trace mode of all threads + q[uit] exit from debugger + v[ar] g[lobal] show global variables + v[ar] l[ocal] show local variables + v[ar] i[nstance] <object> show instance variables of object + v[ar] cl[ass] <object> show class variables of object + v[ar] c[onst] <object> show constants of object + m[ethod] i[nstance] <obj> show methods of object + m[ethod] <class|module> show instance methods of class or module + th[read] l[ist] list all threads + th[read] c[ur[rent]] show current thread + th[read] [sw[itch]] <nnn> switch thread context to nnn + th[read] stop <nnn> stop thread nnn + th[read] resume <nnn> resume thread nnn + p expression evaluate expression and print its value + h[elp] print this help + <everything else> evaluate +EOHELP + end + + def display_expressions(binding) + n = 1 + for d in display + if d[0] + stdout.printf "%d: ", n + display_expression(d[1], binding) + end + n += 1 + end + end + + def display_expression(exp, binding) + stdout.printf "%s = %s\n", exp, debug_silent_eval(exp, binding).to_s + end + + def frame_set_pos(file, line) + if @frames[0] + @frames[0][1] = file + @frames[0][2] = line + end + end + + def display_frames(pos) + 0.upto(@frames.size - 1) do |n| + if n == pos + stdout.print "--> " + else + stdout.print " " + end + stdout.print format_frame(n) + end + end + + def format_frame(pos) + bind, file, line, id = @frames[pos] + sprintf "#%d %s:%s%s\n", pos + 1, file, line, + (id ? ":in `#{id.id2name}'" : "") + end + + def display_list(b, e, file, line) + stdout.printf "[%d, %d] in %s\n", b, e, file + if lines = SCRIPT_LINES__[file] and lines != true + n = 0 + b.upto(e) do |n| + if n > 0 && lines[n-1] + if n == line + stdout.printf "=> %d %s\n", n, lines[n-1].chomp + else + stdout.printf " %d %s\n", n, lines[n-1].chomp + end + end + end + else + stdout.printf "No sourcefile available for %s\n", file + end + end + + def line_at(file, line) + lines = SCRIPT_LINES__[file] + if lines + return "\n" if lines == true + line = lines[line-1] + return "\n" unless line + return line + end + return "\n" + end + + def debug_funcname(id) + if id.nil? + "toplevel" + else + id.id2name + end + end + + def check_break_points(file, klass, pos, binding, id) + return false if break_points.empty? + n = 1 + for b in break_points + if b[0] # valid + if b[1] == 0 # breakpoint + if (b[2] == file and b[3] == pos) or + (klass and b[2] == klass and b[3] == pos) + stdout.printf "Breakpoint %d, %s at %s:%s\n", n, debug_funcname(id), file, pos + return true + end + elsif b[1] == 1 # watchpoint + if debug_silent_eval(b[2], binding) + stdout.printf "Watchpoint %d, %s at %s:%s\n", n, debug_funcname(id), file, pos + return true + end + end + end + n += 1 + end + return false + end + + def excn_handle(file, line, id, binding) + if $!.class <= SystemExit + set_trace_func nil + exit + end + + if @catch and ($!.class.ancestors.find { |e| e.to_s == @catch }) + stdout.printf "%s:%d: `%s' (%s)\n", file, line, $!, $!.class + fs = @frames.size + tb = caller(0)[-fs..-1] + if tb + for i in tb + stdout.printf "\tfrom %s\n", i + end + end + suspend_all + debug_command(file, line, id, binding) + end + end + + def trace_func(event, file, line, id, binding, klass) + Tracer.trace_func(event, file, line, id, binding, klass) if trace? + context(Thread.current).check_suspend + + if not trace_ruby? and + ( file =~ /#{Config::CONFIG['sitelibdir']}/ or + file =~ /#{Config::CONFIG['rubylibdir']}/ or + file =~ %r{/debuggee.rb} ) + case event + when 'line' + frame_set_pos(file, line) + + when 'call' + @frames.unshift [binding, file, line, id] + + when 'c-call' + frame_set_pos(file, line) + + when 'class' + @frames.unshift [binding, file, line, id] + + when 'return', 'end' + @frames.shift + + when 'end' + @frames.shift + + when 'raise' + excn_handle(file, line, id, binding) + + end + return + end + + @file = file + @line = line + case event + when 'line' + frame_set_pos(file, line) + if !@no_step or @frames.size == @no_step + @stop_next -= 1 + @stop_next = -1 if @stop_next < 0 + elsif @frames.size < @no_step + @stop_next = 0 # break here before leaving... + else + # nothing to do. skipped. + end + #LJ reverse the test here because we always want the breakpoint reached + # message to be display. if stop_next is null *AND* there is also a break point + # the message will never display. + if check_break_points(file, nil, line, binding, id) or @stop_next == 0 + # LJ this test doesn't make sense and cause troubles when + # on a line with a recursive call and a breakpoint on it (e.g factorial) + # or when in a while loop with one line only inside the loop + # + # RJD: reinstated the test with a check on whether '@frames.size' + # has changed to catch the recursive factorial case LJ describes + # above. The while loop problem still exists though + if [file, line, @frames.size] == @last + @stop_next = 1 + else + @no_step = nil + suspend_all + debug_command(file, line, id, binding) + @last = [file, line, @frames.size] + end + end + + when 'call' + @frames.unshift [binding, file, line, id] + if check_break_points(file, klass, id.id2name, binding, id) + suspend_all + debug_command(file, line, id, binding) + end + + when 'c-call' + frame_set_pos(file, line) + + when 'class' + @frames.unshift [binding, file, line, id] + + when 'return', 'end' + if @frames.size == @finish_pos + @stop_next = 1 + @finish_pos = 0 + end + @frames.shift + + when 'end' + @frames.shift + + when 'raise' + excn_handle(file, line, id, binding) + + end + @last_file = file + end +end + +trap("INT") { DEBUGGER__.interrupt } +@last_thread = Thread::main +@max_thread = 1 +@thread_list = {Thread::main => 1} +@break_points = [] +@display = [] +@waiting = [] +@stdout = STDOUT + + class SilentObject + def method_missing( msg_id, *a, &b ); end + end + SilentClient = SilentObject.new() + @client = SilentClient + @attached = false + +class << DEBUGGER__ + def stdout + @stdout + end + + def stdout=(s) + @stdout = s + end + + def display + @display + end + + def break_points + @break_points + end + + def client + @client + end + + def set_client( client ) + @client = client + DEBUGGER__.stdout = Tracer.stdout = @client + end + + def quit + #LJ flush STDOUT and ERR +# @stdout.print "Quitting debugger" + STDERR.flush; STDOUT.flush + $stderr.flush; $stdout.flush +# STDERR.close; STDOUT.close + detach + #DebugSvr.stop_service + end + + def detach + @attached = false + @client.detach + set_client( SilentClient ) + end + + def waiting + @waiting + end + + def set_trace( arg ) + saved_crit = Thread.critical + Thread.critical = true + make_thread_list + for th, in @thread_list + context(th).set_trace arg + end + Thread.critical = saved_crit + arg + end + + def set_last_thread(th) + @last_thread = th + end + + def suspend + saved_crit = Thread.critical + Thread.critical = true + make_thread_list + for th, in @thread_list + next if th == Thread.current + context(th).set_suspend + end + Thread.critical = saved_crit + # Schedule other threads to suspend as soon as possible. + Thread.pass unless Thread.critical + end + + def resume + saved_crit = Thread.critical + Thread.critical = true + make_thread_list + for th, in @thread_list + next if th == Thread.current + context(th).clear_suspend + end + waiting.each do |th| + th.run + end + waiting.clear + Thread.critical = saved_crit + # Schedule other threads to restart as soon as possible. + Thread.pass + end + + def context(thread=Thread.current) + c = thread[:__debugger_data__] + unless c + thread[:__debugger_data__] = c = Context.new + end + c + end + + def interrupt + context(@last_thread).stop_next + end + + def get_thread(num) + th = @thread_list.index(num) + unless th + @stdout.print "No thread ##{num}\n" + throw :debug_error + end + th + end + + def thread_list(num) + th = get_thread(num) + if th == Thread.current + @stdout.print "+" + else + @stdout.print " " + end + @stdout.printf "%d ", num + @stdout.print th.inspect, "\t" + file = context(th).instance_eval{@file} + if file + @stdout.print file,":",context(th).instance_eval{@line} + end + @stdout.print "\n" + end + + def thread_list_all + for th in @thread_list.values.sort + thread_list(th) + end + end + + def make_thread_list + hash = {} + for th in Thread::list + if @thread_list.key? th + hash[th] = @thread_list[th] + else + @max_thread += 1 + hash[th] = @max_thread + end + end + @thread_list = hash + end + + def debug_thread_info(input, binding) + case input + when /^l(?:ist)?/ + make_thread_list + thread_list_all + + when /^c(?:ur(?:rent)?)?$/ + make_thread_list + thread_list(@thread_list[Thread.current]) + + when /^(?:sw(?:itch)?\s+)?(\d+)/ + make_thread_list + th = get_thread($1.to_i) + if th == Thread.current + @stdout.print "It's the current thread.\n" + else + thread_list(@thread_list[th]) + context(th).stop_next + th.run + return :cont + end + + when /^stop\s+(\d+)/ + make_thread_list + th = get_thread($1.to_i) + if th == Thread.current + @stdout.print "It's the current thread.\n" + elsif th.stop? + @stdout.print "Already stopped.\n" + else + thread_list(@thread_list[th]) + context(th).suspend + end + + when /^resume\s+(\d+)/ + make_thread_list + th = get_thread($1.to_i) + if th == Thread.current + @stdout.print "It's the current thread.\n" + elsif !th.stop? + @stdout.print "Already running." + else + thread_list(@thread_list[th]) + th.run + end + end + end +end + +require 'socket' + + ## + # DEBUGGEE -> socket -> KDevelop + # The Client class holds all the methods invoked from the debuggee that send and + # receive data from KDevelop via the Unix domain socket. + # + class Client + def initialize(path) + @debugger = UNIXSocket.open(path) + @debugger.sync=true + end + + def detach +# @debugger.close + end + + def printf( *args ) + str = sprintf(*args) + @debugger.send(str, 0) + end + + def print( *args ) + str = args.to_s + @debugger.send(str, 0) + end + + def <<( arg ) + @debugger.send(arg, 0) + end + + # Return next command + def readline(prompt_cmd) + @debugger.send(prompt_cmd, 0) + msg = @debugger.recvfrom(2048) + return msg[0] + end + end + +#stdout.printf "Debug.rb\n" +#stdout.printf "Emacs support available.\n\n" + +STDERR.sync=true +STDOUT.sync=true + +path = $stdin.gets.chomp + +DEBUGGER__.set_client( Client.new(path) ) + +set_trace_func proc { |event, file, line, id, binding, klass, *rest| + + # LJ make sure the file path is always absolute. It is needed by + # the Debugger plugin in KDevelop and can only be determined here + # in the context of the debugged process + file = File.expand_path(file) + + DEBUGGER__.context.trace_func event, file, line, id, binding, klass +} + +end diff --git a/languages/ruby/debugger/debuggerpart.cpp b/languages/ruby/debugger/debuggerpart.cpp new file mode 100644 index 00000000..95b4dd09 --- /dev/null +++ b/languages/ruby/debugger/debuggerpart.cpp @@ -0,0 +1,785 @@ +/*************************************************************************** + * Copyright (C) 1999-2001 by John Birch * + * jbb@kdevelop.org * + * Copyright (C) 2001 by Bernd Gehrmann * + * bernd@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 "debuggerpart.h" + +#include <qdir.h> +#include <qvbox.h> +#include <qwhatsthis.h> +#include <qpopupmenu.h> + +#include <kaction.h> +#include <kdebug.h> +#include <kfiledialog.h> +#include <kdevgenericfactory.h> +#include <kiconloader.h> +#include <klocale.h> +#include <kmainwindow.h> +#include <kstatusbar.h> +#include <kparts/part.h> +#include <ktexteditor/viewcursorinterface.h> +#include <kmessagebox.h> +#include <kapplication.h> +#include <dcopclient.h> +#include <qtimer.h> +#include <kstringhandler.h> +#include <kstandarddirs.h> + +#include "kdevcore.h" +#include "kdevproject.h" +#include "kdevmainwindow.h" +#include "kdevappfrontend.h" +#include "kdevpartcontroller.h" +#include "kdevdebugger.h" +#include "domutil.h" +#include "variablewidget.h" +#include "rdbbreakpointwidget.h" +#include "framestackwidget.h" +#include "processwidget.h" +#include "rdbcontroller.h" +#include "breakpoint.h" +#include "dbgpsdlg.h" +#include "dbgtoolbar.h" +#include "rdbparser.h" +#include "rdboutputwidget.h" +#include "processlinemaker.h" + +#include <iostream> + +#include <kdevplugininfo.h> +#include <debugger.h> + + +namespace RDBDebugger +{ +static const KDevPluginInfo data("kdevrbdebugger"); + +typedef KDevGenericFactory<RubyDebuggerPart> RubyDebuggerFactory; +K_EXPORT_COMPONENT_FACTORY( libkdevrbdebugger, RubyDebuggerFactory( data ) ) + +RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QStringList & ) : + KDevPlugin( &data, parent, name ? name : "RubyDebuggerPart" ), + controller(0) +{ +// setObjId("RubyDebuggerInterface"); + setInstance(RubyDebuggerFactory::instance()); + + setXMLFile("kdevrbdebugger.rc"); + + m_debugger = new Debugger( partController() ); + + statusBarIndicator = new QLabel(" ", mainWindow()->statusBar()); + statusBarIndicator->setFixedWidth(15); + mainWindow()->statusBar()->addWidget(statusBarIndicator, 0, true); + statusBarIndicator->show(); + + // Setup widgets and dbgcontroller + variableWidget = new VariableWidget( 0, "rdbVariablewidget"); +// /*variableWidget*/->setEnabled(false); + variableWidget->setIcon(SmallIcon("math_brace")); + variableWidget->setCaption(i18n("Variable Tree")); + QWhatsThis::add + (variableWidget, i18n("<b>Variable tree</b><p>" + "The variable tree allows you to see " + "the variable values as you step " + "through your program using the internal " + "debugger. Click the right mouse button on items in " + "this view to get a popup menu.\n" + "To speed up stepping through your code " + "leave the tree items closed.\n")); + mainWindow()->embedSelectView(variableWidget, i18n("Variables"), i18n("Debugger variable-view")); + +// mainWindow()->setViewAvailable(variableWidget, false); + + rdbBreakpointWidget = new RDBBreakpointWidget( 0, "rdbBreakpointWidget" ); + rdbBreakpointWidget->setCaption(i18n("Breakpoint List")); + QWhatsThis::add + (rdbBreakpointWidget, i18n("<b>Breakpoint list</b><p>" + "Displays a list of breakpoints with " + "their current status. Clicking on a " + "breakpoint item allows you to change " + "the breakpoint and will take you " + "to the source in the editor window.")); + rdbBreakpointWidget->setIcon( SmallIcon("stop") ); + mainWindow()->embedOutputView(rdbBreakpointWidget, i18n("Breakpoints"), i18n("Debugger breakpoints")); + + framestackWidget = new FramestackWidget( 0, "rdbFramestackWidget" ); + framestackWidget->setEnabled(false); + framestackWidget->setCaption(i18n("Frame Stack")); + QWhatsThis::add + (framestackWidget, i18n("<b>Frame stack</b><p>" + "Often referred to as the \"call stack\", " + "this is a list showing what method is " + "currently active and who called each " + "method to get to this point in your " + "program. By clicking on an item you " + "can see the values in any of the " + "previous calling methods.")); + framestackWidget->setIcon( SmallIcon("table") ); + mainWindow()->embedOutputView(framestackWidget, i18n("Frame Stack"), i18n("Debugger method call stack")); + mainWindow()->setViewAvailable(framestackWidget, false); + + + rdbOutputWidget = new RDBOutputWidget( 0, "rdbOutputWidget" ); + rdbOutputWidget->setEnabled(false); + rdbOutputWidget->setIcon( SmallIcon("inline_image") ); + rdbOutputWidget->setCaption(i18n("RDB Output")); + QWhatsThis::add + (rdbOutputWidget, i18n("<b>RDB output</b><p>" + "Shows all rdb commands being executed. " + "You can also issue any other rdb command while debugging.")); + mainWindow()->embedOutputView(rdbOutputWidget, i18n("RDB"), + i18n("RDB output")); + mainWindow()->setViewAvailable(rdbOutputWidget, false); + + // rdbBreakpointWidget -> this + connect( rdbBreakpointWidget, SIGNAL(refreshBPState(const Breakpoint&)), + this, SLOT(slotRefreshBPState(const Breakpoint&))); + connect( rdbBreakpointWidget, SIGNAL(publishBPState(const Breakpoint&)), + this, SLOT(slotRefreshBPState(const Breakpoint&))); + connect( rdbBreakpointWidget, SIGNAL(gotoSourcePosition(const QString&, int)), + this, SLOT(slotGotoSource(const QString&, int)) ); + + // Now setup the actions + KAction *action; + +// action = new KAction(i18n("&Start"), "1rightarrow", CTRL+SHIFT+Key_F9, + action = new KAction(i18n("&Start"), "dbgrun", CTRL+SHIFT+Key_F9, + this, SLOT(slotRun()), + actionCollection(), "debug_run"); + action->setToolTip( i18n("Start in debugger") ); + action->setWhatsThis( i18n("<b>Start in debugger</b><p>" + "Starts the debugger with the project's main " + "executable. You may set some breakpoints " + "before this, or you can interrupt the program " + "while it is running, in order to get information " + "about variables, frame stack, and so on.") ); + + action = new KAction(i18n("Sto&p"), "stop", 0, + this, SLOT(slotStop()), + actionCollection(), "debug_stop"); + action->setToolTip( i18n("Stop debugger") ); + action->setWhatsThis(i18n("<b>Stop debugger</b><p>Kills the executable and exits the debugger.")); + + action = new KAction(i18n("Interrupt"), "player_pause", 0, + this, SLOT(slotPause()), + actionCollection(), "debug_pause"); + action->setToolTip( i18n("Interrupt application") ); + action->setWhatsThis(i18n("<b>Interrupt application</b><p>Interrupts the debugged process or current RDB command.")); + + action = new KAction(i18n("Run to &Cursor"), "dbgrunto", 0, + this, SLOT(slotRunToCursor()), + actionCollection(), "debug_runtocursor"); + action->setToolTip( i18n("Run to cursor") ); + action->setWhatsThis(i18n("<b>Run to cursor</b><p>Continues execution until the cursor position is reached.")); + + + action = new KAction(i18n("Step &Over"), "dbgnext", 0, + this, SLOT(slotStepOver()), + actionCollection(), "debug_stepover"); + action->setToolTip( i18n("Step over the next line") ); + action->setWhatsThis( i18n("<b>Step over</b><p>" + "Executes one line of source in the current source file. " + "If the source line is a call to a method the whole " + "method is executed and the app will stop at the line " + "following the method call.") ); + + + action = new KAction(i18n("Step &Into"), "dbgstep", 0, + this, SLOT(slotStepInto()), + actionCollection(), "debug_stepinto"); + action->setToolTip( i18n("Step into the next statement") ); + action->setWhatsThis( i18n("<b>Step into</b><p>" + "Executes exactly one line of source. If the source line " + "is a call to a method then execution will stop after " + "the method has been entered.") ); + + + + action = new KAction(i18n("Step O&ut"), "dbgstepout", 0, + this, SLOT(slotStepOut()), + actionCollection(), "debug_stepout"); + action->setToolTip( i18n("Steps out of the current method") ); + action->setWhatsThis( i18n("<b>Step out</b><p>" + "Executes the application until the currently executing " + "method is completed. The debugger will then display " + "the line after the original call to that method. If " + "program execution is in the outermost frame (i.e. in " + "the topleveltoggleWatchpoint) then this operation has no effect.") ); + + + action = new KAction(i18n("Toggle Breakpoint"), 0, 0, + this, SLOT(toggleBreakpoint()), + actionCollection(), "debug_toggle_breakpoint"); + action->setToolTip(i18n("Toggle breakpoint")); + action->setWhatsThis(i18n("<b>Toggle breakpoint</b><p>Toggles the breakpoint at the current line in editor.")); + + connect( mainWindow()->main()->guiFactory(), SIGNAL(clientAdded(KXMLGUIClient*)), + this, SLOT(guiClientAdded(KXMLGUIClient*)) ); + + + connect( partController(), SIGNAL(loadedFile(const KURL &)), + rdbBreakpointWidget, SLOT(slotRefreshBP(const KURL &)) ); + connect( debugger(), SIGNAL(toggledBreakpoint(const QString &, int)), + rdbBreakpointWidget, SLOT(slotToggleBreakpoint(const QString &, int)) ); + connect( debugger(), SIGNAL(editedBreakpoint(const QString &, int)), + rdbBreakpointWidget, SLOT(slotEditBreakpoint(const QString &, int)) ); + connect( debugger(), SIGNAL(toggledBreakpointEnabled(const QString &, int)), + rdbBreakpointWidget, SLOT(slotToggleBreakpointEnabled(const QString &, int)) ); + + connect( core(), SIGNAL(contextMenu(QPopupMenu *, const Context *)), + this, SLOT(contextMenu(QPopupMenu *, const Context *)) ); + + connect( core(), SIGNAL(stopButtonClicked(KDevPlugin*)), + this, SLOT(slotStop(KDevPlugin*)) ); + connect( core(), SIGNAL(projectClosed()), + this, SLOT(projectClosed()) ); + + connect( partController(), SIGNAL(activePartChanged(KParts::Part*)), + this, SLOT(slotActivePartChanged(KParts::Part*)) ); + + procLineMaker = new ProcessLineMaker(); + + connect( procLineMaker, SIGNAL(receivedStdoutLine(const QCString&)), + appFrontend(), SLOT(insertStdoutLine(const QCString&)) ); + connect( procLineMaker, SIGNAL(receivedStderrLine(const QCString&)), + appFrontend(), SLOT(insertStderrLine(const QCString&)) ); + connect( procLineMaker, SIGNAL(receivedPartialStdoutLine(const QCString&)), + appFrontend(), SLOT(addPartialStdoutLine(const QCString&)) ); + connect( procLineMaker, SIGNAL(receivedPartialStderrLine(const QCString&)), + appFrontend(), SLOT(addPartialStderrLine(const QCString&)) ); + + setupController(); + QTimer::singleShot(0, this, SLOT(setupDcop())); +} + +RubyDebuggerPart::~RubyDebuggerPart() +{ + kapp->dcopClient()->setNotifications(false); + + if (variableWidget) + mainWindow()->removeView(variableWidget); + if (rdbBreakpointWidget) + mainWindow()->removeView(rdbBreakpointWidget); + if (framestackWidget) + mainWindow()->removeView(framestackWidget); + if(rdbOutputWidget) + mainWindow()->removeView(rdbOutputWidget); + + delete variableWidget; + delete rdbBreakpointWidget; + delete framestackWidget; + delete rdbOutputWidget; + delete controller; + delete floatingToolBar; + delete statusBarIndicator; + delete procLineMaker; +} + + +void RubyDebuggerPart::guiClientAdded( KXMLGUIClient* client ) +{ + // Can't change state until after XMLGUI has been loaded... + // Anyone know of a better way of doing this? + if( client == this ) + stateChanged( QString("stopped") ); +} + +void RubyDebuggerPart::contextMenu(QPopupMenu *popup, const Context *context) +{ + if (!context->hasType( Context::EditorContext )) + return; + + const EditorContext *econtext = static_cast<const EditorContext*>(context); + m_contextIdent = econtext->currentWord(); + + popup->insertSeparator(); + if (econtext->url().isLocalFile()) + { + int id = popup->insertItem( i18n("Toggle Breakpoint"), this, SLOT(toggleBreakpoint()) ); + popup->setWhatsThis(id, i18n("<b>Toggle breakpoint</b><p>Toggles breakpoint at the current line.")); + } + if (!m_contextIdent.isEmpty()) + { + QString squeezed = KStringHandler::csqueeze(m_contextIdent, 30); + int id = popup->insertItem( i18n("Watch: %1").arg(squeezed), this, SLOT(contextWatch()) ); + popup->setWhatsThis(id, i18n("<b>Watch</b><p>Adds an expression under the cursor to the Variables/Watch list.")); + + id = popup->insertItem( i18n("Inspect: %1").arg(squeezed), this, SLOT(contextRubyInspect()) ); + popup->setWhatsThis(id, i18n("<b>Inspect</b><p>Evaluates an expression under the cursor.")); + } +} + + +void RubyDebuggerPart::toggleBreakpoint() +{ + KParts::ReadWritePart *rwpart + = dynamic_cast<KParts::ReadWritePart*>(partController()->activePart()); + KTextEditor::ViewCursorInterface *cursorIface + = dynamic_cast<KTextEditor::ViewCursorInterface*>(partController()->activeWidget()); + + if (!rwpart || !cursorIface) + return; + + uint line, col; + cursorIface->cursorPositionReal(&line, &col); + + rdbBreakpointWidget->slotToggleBreakpoint(rwpart->url().path(), line); +} + + +void RubyDebuggerPart::contextWatch() +{ + variableWidget->slotAddWatchExpression(m_contextIdent); +} + +// Evaluates the selected text +void RubyDebuggerPart::contextRubyInspect() +{ + emit rubyInspect(m_contextIdent); +} + + +void RubyDebuggerPart::setupController() +{ + VariableTree *variableTree = variableWidget->varTree(); + + controller = new RDBController(variableTree, framestackWidget, *projectDom()); + + // this -> controller + connect( this, SIGNAL(rubyInspect(const QString&)), + controller, SLOT(slotRubyInspect(const QString&))); + + // variableTree -> framestackWidget + connect( variableTree, SIGNAL(selectFrame(int, int)), + framestackWidget, SLOT(slotSelectFrame(int, int))); + + // framestackWidget -> variableTree + connect( framestackWidget, SIGNAL(frameActive(int, int, const QString&)), + variableTree, SLOT(slotFrameActive(int, int, const QString&))); + + // variableTree -> controller + connect( variableTree, SIGNAL(expandItem(VarItem*, const QCString&)), + controller, SLOT(slotExpandItem(VarItem*, const QCString&))); + connect( variableTree, SIGNAL(fetchGlobals(bool)), + controller, SLOT(slotFetchGlobals(bool))); + connect( variableTree, SIGNAL(addWatchExpression(const QString&, bool)), + controller, SLOT(slotAddWatchExpression(const QString&, bool))); + connect( variableTree, SIGNAL(removeWatchExpression(int)), + controller, SLOT(slotRemoveWatchExpression(int))); + + // framestackWidget -> controller + connect( framestackWidget, SIGNAL(selectFrame(int,int,const QString&)), + controller, SLOT(slotSelectFrame(int,int,const QString&))); + + // rdbBreakpointWidget -> controller + connect( rdbBreakpointWidget, SIGNAL(clearAllBreakpoints()), + controller, SLOT(slotClearAllBreakpoints())); + connect( rdbBreakpointWidget, SIGNAL(publishBPState(const Breakpoint&)), + controller, SLOT(slotBPState(const Breakpoint &))); + + + // rdbOutputWidget -> controller + connect( rdbOutputWidget, SIGNAL(userRDBCmd(const QString &)), + controller, SLOT(slotUserRDBCmd(const QString&))); + connect( rdbOutputWidget, SIGNAL(breakInto()), + controller, SLOT(slotBreakInto())); + + // controller -> rdbBreakpointWidget + connect( controller, SIGNAL(acceptPendingBPs()), + rdbBreakpointWidget, SLOT(slotSetPendingBPs())); + connect( controller, SIGNAL(unableToSetBPNow(int)), + rdbBreakpointWidget, SLOT(slotUnableToSetBPNow(int))); + connect( controller, SIGNAL(rawRDBBreakpointList (char*)), + rdbBreakpointWidget, SLOT(slotParseRDBBrkptList(char*))); + connect( controller, SIGNAL(rawRDBBreakpointSet(char*, int)), + rdbBreakpointWidget, SLOT(slotParseRDBBreakpointSet(char*, int))); + + + // controller -> this + connect( controller, SIGNAL(dbgStatus(const QString&, int)), + this, SLOT(slotStatus(const QString&, int))); + connect( controller, SIGNAL(showStepInSource(const QString&, int, const QString&)), + this, SLOT(slotShowStep(const QString&, int))); + + // controller -> procLineMaker + connect( controller, SIGNAL(ttyStdout(const char*)), + procLineMaker, SLOT(slotReceivedStdout(const char*))); + connect( controller, SIGNAL(ttyStderr(const char*)), + procLineMaker, SLOT(slotReceivedStderr(const char*))); + + // controller -> rdbOutputWidget + connect( controller, SIGNAL(rdbStdout(const char*)), + rdbOutputWidget, SLOT(slotReceivedStdout(const char*)) ); + connect( controller, SIGNAL(rdbStderr(const char*)), + rdbOutputWidget, SLOT(slotReceivedStderr(const char*)) ); + connect( controller, SIGNAL(dbgStatus(const QString&, int)), + rdbOutputWidget, SLOT(slotDbgStatus(const QString&, int))); + +} + + +bool RubyDebuggerPart::startDebugger() +{ + QString build_dir; // Currently selected build directory + QString run_directory; // Directory from where the program should be run + QString program; // Absolute path to application + QString run_arguments; // Command line arguments to be passed to the application + QString ruby_interpreter; // Absolute path to the ruby interpreter + QString debuggee_path; // Absolute path to debuggee.rb debugger script + bool show_constants; // Show constants in the debugger + bool trace_into_ruby; // Trace into the ruby code installed under sitedir + + if (project()) { + build_dir = project()->buildDirectory(); + run_directory = DomUtil::readEntry(*projectDom(), "/kdevscriptproject/run/globalcwd"); + if (run_directory.isEmpty()) + run_directory = project()->buildDirectory(); + } + + int runMainProgram = DomUtil::readIntEntry(*projectDom(), "/kdevrubysupport/run/runmainprogram"); + + if (runMainProgram == 0) { + program = project()->projectDirectory() + "/" + DomUtil::readEntry(*projectDom(), "/kdevrubysupport/run/mainprogram"); + } else { + KParts::ReadOnlyPart *ro_part = dynamic_cast<KParts::ReadOnlyPart*>(partController()->activePart()); + if (ro_part != 0) { + program = ro_part->url().path(); + } + } + + run_arguments = DomUtil::readEntry(*projectDom(), "/kdevrubysupport/run/programargs"); + + QString shell = DomUtil::readEntry(*projectDom(), "/kdevrbdebugger/general/dbgshell"); + if( !shell.isEmpty() ) + { + QFileInfo info( shell ); + if( info.isRelative() ) + { + shell = build_dir + "/" + shell; + info.setFile( shell ); + } + if( !info.exists() ) + { + KMessageBox::error( + mainWindow()->main(), + i18n("Could not locate the debugging shell '%1'.").arg( shell ), + i18n("Debugging Shell Not Found") ); + return false; + } + } + + core()->running(this, true); + + stateChanged( QString("active") ); + + KActionCollection *ac = actionCollection(); + ac->action("debug_run")->setText( i18n("&Continue") ); +// ac->action("debug_run")->setIcon( "dbgrun" ); + ac->action("debug_run")->setToolTip( i18n("Continues the application execution") ); + ac->action("debug_run")->setWhatsThis( i18n("Continue application execution\n\n" + "Continues the execution of your application in the " + "debugger. This only takes effect when the application " + "has been halted by the debugger (i.e. a breakpoint has " + "been activated or the interrupt was pressed).") ); + + +// mainWindow()->setViewAvailable(variableWidget, true); + mainWindow()->setViewAvailable(framestackWidget, true); + mainWindow()->setViewAvailable(rdbOutputWidget, true); + +// variableWidget->setEnabled(true); + framestackWidget->setEnabled(true); + + rdbOutputWidget->clear(); + rdbOutputWidget->setEnabled(true); + + if (DomUtil::readBoolEntry(*projectDom(), "/kdevrbdebugger/general/floatingtoolbar", false)) + { + floatingToolBar = new DbgToolBar(this, mainWindow()->main()); + floatingToolBar->show(); + } + + ruby_interpreter = DomUtil::readEntry(*projectDom(), "/kdevrubysupport/run/interpreter"); + + int coding = DomUtil::readIntEntry(*projectDom(), "/kdevrubysupport/run/charactercoding"); + QString character_coding("-K"); + + switch (coding) { + case 0: + character_coding.append("A"); + break; + case 1: + character_coding.append("E"); + break; + case 2: + character_coding.append("S"); + break; + case 3: + character_coding.append("U"); + break; + } + +// ruby_interpreter.append(QString(" -K") + code); + + debuggee_path = ::locate("data", "kdevrbdebugger/debuggee.rb", instance()); + + show_constants = DomUtil::readBoolEntry(*projectDom(), "/kdevrbdebugger/general/showconstants"); + trace_into_ruby = DomUtil::readBoolEntry(*projectDom(), "/kdevrbdebugger/general/traceintoruby"); + + controller->slotStart(ruby_interpreter, character_coding, run_directory, debuggee_path, program, run_arguments, show_constants, trace_into_ruby); + return true; +} + +void RubyDebuggerPart::slotStopDebugger() +{ + controller->slotStopDebugger(); + debugger()->clearExecutionPoint(); + + delete floatingToolBar; + floatingToolBar = 0; + + rdbBreakpointWidget->reset(); + framestackWidget->clear(); + variableWidget->varTree()->clear(); + +// variableWidget->setEnabled(false); + framestackWidget->setEnabled(false); + rdbOutputWidget->setEnabled(false); + +// mainWindow()->setViewAvailable(variableWidget, false); + mainWindow()->setViewAvailable(framestackWidget, false); + mainWindow()->setViewAvailable(rdbOutputWidget, false); + + KActionCollection *ac = actionCollection(); + ac->action("debug_run")->setText( i18n("&Start") ); +// ac->action("debug_run")->setIcon( "1rightarrow" ); + ac->action("debug_run")->setToolTip( i18n("Runs the program in the debugger") ); + ac->action("debug_run")->setWhatsThis( i18n("Start in debugger\n\n" + "Starts the debugger with the project's main " + "executable. You may set some breakpoints " + "before this, or you can interrupt the program " + "while it is running, in order to get information " + "about variables, frame stack, and so on.") ); + + stateChanged( QString("stopped") ); + + core()->running(this, false); +} + +void RubyDebuggerPart::projectClosed() +{ + slotStopDebugger(); +} + +void RubyDebuggerPart::slotRun() +{ + if (controller->stateIsOn(s_programExited)) { + rdbBreakpointWidget->reset(); + } + + if ( controller->stateIsOn( s_dbgNotStarted ) ) { + mainWindow()->statusBar()->message(i18n("Debugging program"), 1000); + mainWindow()->raiseView(rdbOutputWidget); + appFrontend()->clearView(); + startDebugger(); + } else { + KActionCollection *ac = actionCollection(); + ac->action("debug_run")->setText( i18n("&Continue") ); + ac->action("debug_run")->setToolTip( i18n("Continues the application execution") ); + ac->action("debug_run")->setWhatsThis( i18n("Continue application execution\n\n" + "Continues the execution of your application in the " + "debugger. This only takes effect when the application " + "has been halted by the debugger (i.e. a breakpoint has " + "been activated or the interrupt was pressed).") ); + + mainWindow()->statusBar()->message(i18n("Continuing program"), 1000); + } + + controller->slotRun(); +} + + + +void RubyDebuggerPart::slotStop(KDevPlugin* which) +{ + if( which != 0 && which != this ) + return; + +// if( !controller->stateIsOn( s_dbgNotStarted ) && !controller->stateIsOn( s_shuttingDown ) ) + slotStopDebugger(); +} + + +void RubyDebuggerPart::slotPause() +{ + controller->slotBreakInto(); +} + + +void RubyDebuggerPart::slotRunToCursor() +{ + KParts::ReadWritePart *rwpart + = dynamic_cast<KParts::ReadWritePart*>(partController()->activePart()); + KTextEditor::ViewCursorInterface *cursorIface + = dynamic_cast<KTextEditor::ViewCursorInterface*>(partController()->activeWidget()); + + if (!rwpart || !rwpart->url().isLocalFile() || !cursorIface) + return; + + uint line, col; + cursorIface->cursorPosition(&line, &col); + + controller->slotRunUntil(rwpart->url().path(), line); +} + +void RubyDebuggerPart::slotStepOver() +{ + controller->slotStepOver(); +} + + + +void RubyDebuggerPart::slotStepInto() +{ + controller->slotStepInto(); +} + + +void RubyDebuggerPart::slotStepOut() +{ + controller->slotStepOutOff(); +} + + + + +void RubyDebuggerPart::slotRefreshBPState( const Breakpoint& BP) +{ + if (BP.type() == BP_TYPE_FilePos) + { + const FilePosBreakpoint& bp = dynamic_cast<const FilePosBreakpoint&>(BP); + if (bp.isActionDie()) + debugger()->setBreakpoint(bp.fileName(), bp.lineNum()-1, -1, true, false); + else + debugger()->setBreakpoint(bp.fileName(), bp.lineNum()-1, + 1/*bp->id()*/, bp.isEnabled(), bp.isPending() ); + } +} + + +void RubyDebuggerPart::slotStatus(const QString &msg, int state) +{ + QString stateIndicator; + + if (state & s_dbgNotStarted) + { + stateIndicator = " "; + } + else if (state & s_appBusy) + { + stateIndicator = "A"; + debugger()->clearExecutionPoint(); + stateChanged( QString("active") ); + } + else if (state & s_programExited) + { + stateIndicator = "E"; + stateChanged( QString("stopped") ); + KActionCollection *ac = actionCollection(); + ac->action("debug_run")->setText( i18n("Restart") ); +// ac->action("debug_run")->setIcon( "1rightarrow" ); + ac->action("debug_run")->setToolTip( i18n("Restart the program in the debugger") ); + ac->action("debug_run")->setWhatsThis( i18n("Restart in debugger\n\n" + "Restarts the program in the debugger") ); +// slotStop(); + } + else + { + stateIndicator = "P"; + stateChanged( QString("paused") ); + } + + // And now? :-) + kdDebug(9012) << "Debugger state: " << stateIndicator << ": " << endl; + kdDebug(9012) << " " << msg << endl; + + statusBarIndicator->setText(stateIndicator); + if (!msg.isEmpty()) + mainWindow()->statusBar()->message(msg, 3000); +} + + +void RubyDebuggerPart::slotShowStep(const QString &fileName, int lineNum) +{ + if ( ! fileName.isEmpty() ) + { + // Debugger counts lines from 1 + debugger()->gotoExecutionPoint(KURL( fileName ), lineNum-1); + } +} + + +void RubyDebuggerPart::slotGotoSource(const QString &fileName, int lineNum) +{ + if ( ! fileName.isEmpty() ) + partController()->editDocument(KURL( fileName ), lineNum); +} + + +void RubyDebuggerPart::slotActivePartChanged( KParts::Part* part ) +{ + KAction* action = actionCollection()->action("debug_toggle_breakpoint"); + if(!action) + return; + + if(!part) + { + action->setEnabled(false); + return; + } + KTextEditor::ViewCursorInterface *iface + = dynamic_cast<KTextEditor::ViewCursorInterface*>(part->widget()); + action->setEnabled( iface != 0 ); +} + +void RubyDebuggerPart::restorePartialProjectSession(const QDomElement* el) +{ + rdbBreakpointWidget->restorePartialProjectSession(el); + variableWidget->restorePartialProjectSession(el); +} + +void RubyDebuggerPart::savePartialProjectSession(QDomElement* el) +{ + rdbBreakpointWidget->savePartialProjectSession(el); + variableWidget->savePartialProjectSession(el); +} + +} + +KDevAppFrontend * RDBDebugger::RubyDebuggerPart::appFrontend( ) +{ + return extension<KDevAppFrontend>("KDevelop/AppFrontend"); +} + +KDevDebugger * RDBDebugger::RubyDebuggerPart::debugger() +{ + return m_debugger; +} + +#include "debuggerpart.moc" diff --git a/languages/ruby/debugger/debuggerpart.h b/languages/ruby/debugger/debuggerpart.h new file mode 100644 index 00000000..2f35df9a --- /dev/null +++ b/languages/ruby/debugger/debuggerpart.h @@ -0,0 +1,110 @@ +/*************************************************************************** + * Copyright (C) 1999-2001 by John Birch * + * jbb@kdevelop.org * + * Copyright (C) 2001 by Bernd Gehrmann * + * bernd@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. * + * * + ***************************************************************************/ + +#ifndef _DEBUGGERPART_H_ +#define _DEBUGGERPART_H_ + +#include <qguardedptr.h> +#include "kdevplugin.h" +#include "kdevcore.h" + +namespace KParts { class Part; } + +class QLabel; +class QPopupMenu; +class KDialogBase; +class ProcessWidget; +class ProcessLineMaker; +class KDevAppFrontend; +class KDevDebugger; + +namespace RDBDebugger +{ + +class RDBBreakpointWidget; +class FramestackWidget; +class Breakpoint; +class DbgController; +class DbgToolBar; +class VariableWidget; +class RDBOutputWidget; + +class RubyDebuggerPart : public KDevPlugin +{ + Q_OBJECT + +public: + RubyDebuggerPart( QObject *parent, const char *name, const QStringList & ); + ~RubyDebuggerPart(); + virtual void restorePartialProjectSession(const QDomElement* el); + virtual void savePartialProjectSession(QDomElement* el); + +private slots: + void guiClientAdded(KXMLGUIClient*); + void contextMenu(QPopupMenu *popup, const Context *context); + void toggleBreakpoint(); + void contextWatch(); + void contextRubyInspect(); +// void projectOpened(); + void projectClosed(); + void slotActivePartChanged(KParts::Part*); + + void slotRun(); + void slotStopDebugger(); + void slotStop(KDevPlugin* which = 0); + void slotPause(); + void slotRunToCursor(); + void slotStepOver(); + void slotStepInto(); + void slotStepOut(); + + void slotRefreshBPState(const Breakpoint&); + void slotStatus(const QString &msg, int state); + void slotShowStep(const QString &fileName, int lineNum); + void slotGotoSource(const QString &fileName, int lineNum); + +signals: + void rubyInspect(const QString&); + +private: + KDevAppFrontend *appFrontend(); + KDevDebugger *debugger(); + + bool startDebugger(); + void setupController(); + + QGuardedPtr<VariableWidget> variableWidget; + QGuardedPtr<RDBBreakpointWidget> rdbBreakpointWidget; + QGuardedPtr<FramestackWidget> framestackWidget; + QGuardedPtr<RDBOutputWidget> rdbOutputWidget; + DbgController *controller; + QGuardedPtr<QLabel> statusBarIndicator; + QGuardedPtr<DbgToolBar> floatingToolBar; + ProcessLineMaker* procLineMaker; + ProcessLineMaker* rdbLineMaker; + + QString m_contextIdent; + QCString m_drkonqi; + + KDevDebugger *m_debugger; +}; + +} + +#endif diff --git a/languages/ruby/debugger/framestackwidget.cpp b/languages/ruby/debugger/framestackwidget.cpp new file mode 100644 index 00000000..836350b2 --- /dev/null +++ b/languages/ruby/debugger/framestackwidget.cpp @@ -0,0 +1,272 @@ +/*************************************************************************** + 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 "framestackwidget.h" +#include "rdbparser.h" + +#include <klocale.h> +#include <kdebug.h> + +#include <qheader.h> +#include <qlistbox.h> +#include <qregexp.h> +#include <qstrlist.h> +#include <qfileinfo.h> + +#include <ctype.h> + + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +namespace RDBDebugger +{ + +FramestackWidget::FramestackWidget(QWidget *parent, const char *name, WFlags f) + : QListView(parent, name, f), + viewedThread_(0) +{ + setRootIsDecorated(true); + setSelectionMode(Single); + addColumn(QString()); + setSorting(0); + header()->hide(); + + connect( this, SIGNAL(clicked(QListViewItem*)), + this, SLOT(slotSelectionChanged(QListViewItem*)) ); +} + + +/***************************************************************************/ + +FramestackWidget::~FramestackWidget() +{ +} + + +// ************************************************************************** + +void FramestackWidget::clear() +{ + viewedThread_ = 0; + QListView::clear(); +} + +/***************************************************************************/ + +void FramestackWidget::slotSelectionChanged(QListViewItem * item) +{ + if (item == 0) { + return; + } + + if (item->rtti() == RTTI_THREAD_STACK_ITEM) { + ThreadStackItem * thread = (ThreadStackItem*) item; + slotSelectFrame(1, thread->threadNo()); + } else if (item->rtti() == RTTI_FRAME_STACK_ITEM) { + FrameStackItem * frame = (FrameStackItem*) item; + slotSelectFrame(frame->frameNo(), frame->threadNo()); + } + + return; +} + +/***************************************************************************/ + +void FramestackWidget::slotSelectFrame(int frameNo, int threadNo) +{ + FrameStackItem * frame = findFrame(frameNo, threadNo); + + if (frame != 0) { + setSelected(frame, true); + emit selectFrame(frameNo, threadNo, frame->frameName()); + } else { + emit selectFrame(frameNo, threadNo, QString()); + } +} + +/***************************************************************************/ + +void FramestackWidget::parseRDBThreadList(char *str) +{ + // on receipt of a thread list we must always clear the list. + clear(); + + QRegExp thread_re("(\\+)?\\s*(\\d+)\\s*(#<[^>]+>\\s*[^:]+:\\d+)"); + int pos = thread_re.search(str); + viewedThread_ = 0; + + while (pos != -1) { + ThreadStackItem* thread; + thread = new ThreadStackItem( this, + thread_re.cap(2).toInt(), + QString("%1 %2").arg(thread_re.cap(2)).arg(thread_re.cap(3)) ); + // The thread with a '+' is always the viewedthread + if (thread_re.cap(1) == "+") { + viewedThread_ = thread; + } + + pos += thread_re.matchedLength(); + pos = thread_re.search(str, pos); + } + + return; +} + +/***************************************************************************/ + +void FramestackWidget::parseRDBBacktraceList(char *str) +{ + QRegExp frame_re("#(\\d+) ([^:]+):(\\d+)(:in `([^\\n]+)')?"); + int pos = frame_re.search(str); + + while (pos != -1) { + QString method(frame_re.cap(5)); + if (method == "") { + method = "toplevel"; + } else { + method.append("(...)"); + } + + int frameNo = frame_re.cap(1).toInt(); + QString frameName = QString("T%1#%2 %3").arg(viewedThread_->threadNo()).arg(frame_re.cap(1)).arg(method); + new FrameStackItem(viewedThread_, frameNo, QString(frame_re.cap(0)), frameName); + + // Tell the Variable Tree that this frame is active + emit frameActive(frameNo, viewedThread_->threadNo(), frameName); + + pos += frame_re.matchedLength(); + pos = frame_re.search(str, pos); + } + + if (viewedThread_ != 0) { + viewedThread_->setOpen(true); + } + + return; +} + +// ************************************************************************** + +ThreadStackItem *FramestackWidget::findThread(int threadNo) +{ + QListViewItem *sibling = firstChild(); + while (sibling != 0) { + ThreadStackItem *thread = (ThreadStackItem*) sibling; + if (thread->threadNo() == threadNo) { + return thread; + } + sibling = sibling->nextSibling(); + } + + return 0; +} + +// ************************************************************************** + +FrameStackItem *FramestackWidget::findFrame(int frameNo, int threadNo) +{ + ThreadStackItem * thread = findThread(threadNo); + if (thread == 0) { + kdDebug(9012) << "FramestackWidget::findFrame: no matching thread " << + frameNo << " thread: " << threadNo << endl; + return 0; // no matching thread? + } + + QListViewItem * frameItem = thread->firstChild(); + + while (frameItem != 0) { + if (((FrameStackItem *) frameItem)->frameNo() == frameNo) { + return (FrameStackItem *) frameItem; + } + + frameItem = frameItem->nextSibling(); + } + + return 0; +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +// ************************************************************************** + +FrameStackItem::FrameStackItem(ThreadStackItem *parent, int frameNo, const QString &frameDesc, const QString& frameName) + : QListViewItem(parent), + frameNo_(frameNo), + threadNo_(parent->threadNo()), + frameName_(frameName) +{ + setText(0, frameDesc); + key_.sprintf("%.6d", frameNo_); +} + +// ************************************************************************** + +FrameStackItem::~FrameStackItem() +{ +} + +// ************************************************************************** + +QString FrameStackItem::key(int /*column*/, bool /*ascending*/) const +{ + + return key_; +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +ThreadStackItem::ThreadStackItem(FramestackWidget *parent, int threadNo, const QString &threadDesc) + : QListViewItem(parent), + threadNo_(threadNo) +{ + setText(0, threadDesc); + setExpandable(true); +} + +// ************************************************************************** + +ThreadStackItem::~ThreadStackItem() +{ +} + +// ************************************************************************** + +void ThreadStackItem::setOpen(bool open) +{ + if (open) + ((FramestackWidget*)listView())->slotSelectFrame(1, threadNo()); + + QListViewItem::setOpen(open); +} + +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +#include "framestackwidget.moc" diff --git a/languages/ruby/debugger/framestackwidget.h b/languages/ruby/debugger/framestackwidget.h new file mode 100644 index 00000000..373d0690 --- /dev/null +++ b/languages/ruby/debugger/framestackwidget.h @@ -0,0 +1,115 @@ +/*************************************************************************** + 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. * + * * + ***************************************************************************/ + +#ifndef _FRAMESTACKWIDGET_H_ +#define _FRAMESTACKWIDGET_H_ + +#include <qlistview.h> +#include <qstringlist.h> + +#include "rdbcontroller.h" + +namespace RDBDebugger +{ + +class FramestackWidget; + + +class ThreadStackItem : public QListViewItem +{ +public: + ThreadStackItem(FramestackWidget *parent, int threadNo, const QString &threadDesc); + virtual ~ThreadStackItem(); + + virtual int rtti() const { return RTTI_THREAD_STACK_ITEM; } + + void setOpen(bool open); + int threadNo() { return threadNo_; } + +private: + int threadNo_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class FrameStackItem : public QListViewItem +{ +public: + FrameStackItem(ThreadStackItem * parent, int frameNo, const QString & frameDesc, const QString & frameName); + virtual ~FrameStackItem(); + + virtual int rtti() const { return RTTI_FRAME_STACK_ITEM; } + virtual QString key(int column, bool ascending) const; + + int frameNo() { return frameNo_; } + int threadNo() { return threadNo_; } + QString frameName() { return frameName_; } + +private: + int frameNo_; + int threadNo_; + QString frameName_; + QString key_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +/** + * @author John Birch + */ +class FramestackWidget : public QListView +{ + Q_OBJECT + +public: + FramestackWidget( QWidget *parent=0, const char *name=0, WFlags f=0 ); + virtual ~FramestackWidget(); + + void clear(); + + void parseRDBThreadList(char *str); + void parseRDBBacktraceList(char *str); + + ThreadStackItem *findThread(int threadNo); + FrameStackItem *findFrame(int frameNo, int threadNo); + + int viewedThread() + { return viewedThread_ ? viewedThread_->threadNo() : -1; } + +public slots: + void slotSelectFrame(int frameNo, int threadNo); + void slotSelectionChanged(QListViewItem *thisItem); + +signals: + void selectFrame(int frameNo, int threadNo, const QString& frameName); + void frameActive(int frameNo, int threadNo, const QString& frameName); + +private: + ThreadStackItem *viewedThread_; +}; + +} + +#endif diff --git a/languages/ruby/debugger/hi16-action-breakpoint_add.png b/languages/ruby/debugger/hi16-action-breakpoint_add.png Binary files differnew file mode 100644 index 00000000..1b41040c --- /dev/null +++ b/languages/ruby/debugger/hi16-action-breakpoint_add.png diff --git a/languages/ruby/debugger/hi16-action-breakpoint_delete.png b/languages/ruby/debugger/hi16-action-breakpoint_delete.png Binary files differnew file mode 100644 index 00000000..c35e039f --- /dev/null +++ b/languages/ruby/debugger/hi16-action-breakpoint_delete.png diff --git a/languages/ruby/debugger/hi16-action-breakpoint_delete_all.png b/languages/ruby/debugger/hi16-action-breakpoint_delete_all.png Binary files differnew file mode 100644 index 00000000..c35e039f --- /dev/null +++ b/languages/ruby/debugger/hi16-action-breakpoint_delete_all.png diff --git a/languages/ruby/debugger/hi16-action-breakpoint_edit.png b/languages/ruby/debugger/hi16-action-breakpoint_edit.png Binary files differnew file mode 100644 index 00000000..ec92ced2 --- /dev/null +++ b/languages/ruby/debugger/hi16-action-breakpoint_edit.png diff --git a/languages/ruby/debugger/kdevrbdebugger.desktop b/languages/ruby/debugger/kdevrbdebugger.desktop new file mode 100644 index 00000000..47e59474 --- /dev/null +++ b/languages/ruby/debugger/kdevrbdebugger.desktop @@ -0,0 +1,73 @@ +[Desktop Entry] +Type=Service +Exec=blubb +Comment=This plugin provides a frontend for the source-level debugger for Ruby. +Comment[ca]=Aquest connector proveeix una interfície per a la depuració a nivell de codi per a Ruby. +Comment[da]=Dette plugin sørger for en grænseflade til Ruby kildekode-fejlretteren. +Comment[de]=Dieses Modul stellt eine Oberfläche für den Quelltext-Debugger für Ruby bereit. +Comment[el]=Αυτό το πρόσθετο προσφέρει ένα πρόγραμμα για τον αποσφαλματωτή πηγαίου κώδικα της γλώσσας Ruby. +Comment[es]=Este complemento proporciona un entorno para depurar código de Ruby. +Comment[et]=See plugin pakub Ruby lähtekoodi siluri kasutajaliidest. +Comment[eu]=Plugin honek Ruby-ren iturburu-mailako araztailearen interfaze bat bat eskeintzen du. +Comment[fa]=این وصله، یک پایانه برای اشکالزدای سطح منبع رابی فراهم میکند. +Comment[fr]=Ce module externe fournit une interface pour le débogueur au niveau source pour Ruby. +Comment[gl]=Esta extensión proporciona un frontal para o depurador a nivel de código de Ruby. +Comment[hu]=Ez a bővítőmodul grafikus felületet biztosít a Ruby forrásszintű nyomkövetőjének használatához. +Comment[it]=Questo plugin fornisce un'interfaccia per il debugger a livello sorgente di Ruby. +Comment[ja]=このプラグインは、Ruby のソースレベルデバッガのフロントエンドを提供します。 +Comment[nds]=Dit Moduul stellt en Böversiet för den Ruby-Borntextfehlersöker praat. +Comment[ne]=यो प्लगइनले रूबिका लागि स्रोत-तह डिबगरका लागि फ्रेन्टइन्ड प्रदान गर्दछ । +Comment[nl]=Deze plugin biedt een grafische schil voor de broncode-debugger voor Ruby. +Comment[pl]=Ta wtyczka udostępnia interfejs do debugera poziomu źródłowego dla języka Ruby. +Comment[pt]=Este 'plugin' oferece uma interface o depurador ao nível do código para Ruby. +Comment[pt_BR]=Este plug-in fornece uma interface para o depurador a nível de código para Ruby. +Comment[ru]=Этот модуль предоставляет интерфейс к отладчику исходного кода для Ruby. +Comment[sk]=Modul pre rozhranie debugera pre Ruby. +Comment[sr]=Овај прикључак обезбеђује интерфејс за исправљач на нивоу изворног кода за Ruby. +Comment[sr@Latn]=Ovaj priključak obezbeđuje interfejs za ispravljač na nivou izvornog koda za Ruby. +Comment[sv]=Insticksprogrammet tillhandahåller ett gränssnitt till källkodsavlusaren för Ruby. +Comment[tr]=Bu eklenti, Ruby için kaynak-düzeyi hata ayıklayıcıya bir önuç sağlar. +Comment[zh_CN]=此插件提供了一个 Ruby 的源代码级调试器的前端。 +Comment[zh_TW]=此外掛程式提供 Ruby 除錯器的前端介面。 +Name=KDevRbDebugger +Name[da]=KDevelop Ruby fejlretter +Name[nds]=Ruby-Fehlersöök för KDevelop +Name[pl]=KDevDebugerRb +Name[sk]=KDev Ruby debuger +Name[sv]=KDevelop Ruby-avlusare +Name[zh_TW]=KDevelop Ruby 除錯器 +GenericName=Ruby Debugger Frontend +GenericName[ca]=Interfície per al depurador Ruby +GenericName[da]=Ruby fejlretningsgrænseflade +GenericName[de]=Debugger-Oberfläche für Ruby +GenericName[el]=Πρόγραμμα αποσφαλματωτή Ruby +GenericName[es]=Interfaz para el depurador de Ruby +GenericName[et]=Ruby siluri kasutajaliides +GenericName[eu]=Ruby araztailearen interfazea +GenericName[fa]=پایانۀ اشکالزدای رابی +GenericName[fr]=Interface du débogueur pour Ruby +GenericName[gl]=Frontal do depurador Ruby +GenericName[hu]=Grafikus felület a Ruby nyomkövetőjéhez +GenericName[it]=Interfaccia di debug per Ruby +GenericName[ja]=Ruby デバッガフロントエンド +GenericName[nds]=Böversiet för den Ruby-Fehlersöker +GenericName[ne]=रूबि डिबगर फ्रेन्टइन्ड +GenericName[nl]=Grafische schil voor de Ruby-debugger +GenericName[pl]=Interfejs do debugera dla języka Ruby +GenericName[pt]=Interface de Depuração Ruby +GenericName[pt_BR]=Interface para o Depurador Ruby +GenericName[ru]=Интегрированный отладчик Ruby +GenericName[sk]=Ruby debuger rozhranie +GenericName[sr]=Интерфејс исправљача за Ruby +GenericName[sr@Latn]=Interfejs ispravljača za Ruby +GenericName[sv]=Gränssnitt för Ruby-avlusare +GenericName[tr]=Ruby Hata Ayıklayıcı Önucu +GenericName[zh_CN]=Ruby 调试器前端 +GenericName[zh_TW]=Ruby 除錯器前端介面 +Icon= +ServiceTypes=KDevelop/Plugin +X-KDE-Library=libkdevrbdebugger +X-KDevelop-Version=5 +X-KDevelop-Scope=Project +X-KDevelop-ProgrammingLanguages=Ruby +X-KDevelop-Properties=RubyDebugger diff --git a/languages/ruby/debugger/kdevrbdebugger.rc b/languages/ruby/debugger/kdevrbdebugger.rc new file mode 100644 index 00000000..c7e3b336 --- /dev/null +++ b/languages/ruby/debugger/kdevrbdebugger.rc @@ -0,0 +1,68 @@ +<!DOCTYPE kpartgui SYSTEM "kpartgui.dtd"> +<kpartgui name="KDevRbDebugger" version="10"> +<MenuBar> + <Menu name="debug"> + <text>&Debug</text> + <Action name="debug_run" group="debug"/> + <Action name="debug_stop" group="debug"/> + <Action name="debug_pause" group="debug"/> + <Action name="debug_runtocursor" group="debug"/> + <Separator group="debug"/> + <Action name="debug_stepover" group="debug"/> + <Action name="debug_stepinto" group="debug"/> + <Action name="debug_stepout" group="debug"/> + <Separator group="debug"/> + <Action name="debug_toggle_breakpoint" group="debug"/> + <Action name="debug_disable_breakpoint" group="debug"/> + <Separator group="debug"/> + </Menu> +</MenuBar> +<ToolBar name="debugToolBar"> + <text>Debugger Toolbar</text> + <Action name="debug_run"/> + <Action name="debug_stepover"/> + <Action name="debug_stepinto"/> + <Action name="debug_stepout"/> + <WeakSeparator/> +</ToolBar> +<State name="stopped"> + <enable> + <Action name="debug_run"/> + </enable> + <disable> + <Action name="debug_stop"/> + <Action name="debug_pause"/> + <Action name="debug_runtocursor"/> + <Action name="debug_stepover"/> + <Action name="debug_stepinto"/> + <Action name="debug_stepout"/> + </disable> +</State> +<State name="paused"> + <enable> + <Action name="debug_run"/> + <Action name="debug_stop"/> + <Action name="debug_runtocursor"/> + <Action name="debug_stepover"/> + <Action name="debug_stepinto"/> + <Action name="debug_stepout"/> + </enable> + <disable> + <Action name="debug_pause"/> + </disable> +</State> +<State name="active"> + <enable> + <Action name="debug_pause"/> + <Action name="debug_stop"/> + </enable> + <disable> + <Action name="debug_run"/> + <Action name="debug_runtocursor"/> + <Action name="debug_stepover"/> + <Action name="debug_stepinto"/> + <Action name="debug_stepout"/> + </disable> +</State> +</kpartgui> + diff --git a/languages/ruby/debugger/rdbbreakpointwidget.cpp b/languages/ruby/debugger/rdbbreakpointwidget.cpp new file mode 100644 index 00000000..e31831de --- /dev/null +++ b/languages/ruby/debugger/rdbbreakpointwidget.cpp @@ -0,0 +1,921 @@ +/*************************************************************************** + begin : Tue May 13 2003 + copyright : (C) 2003 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 "rdbbreakpointwidget.h" +#include "rdbtable.h" + +#include "breakpoint.h" +#include "domutil.h" + +#include <kdebug.h> +#include <kiconloader.h> +#include <klocale.h> +#include <kpopupmenu.h> +#include <kurl.h> + +#include <qvbuttongroup.h> +#include <qfileinfo.h> +#include <qheader.h> +#include <qtable.h> +#include <qtoolbutton.h> +#include <qtooltip.h> +#include <qwhatsthis.h> +#include <qvbox.h> +#include <qlayout.h> +#include <qregexp.h> + +#include <stdlib.h> +#include <ctype.h> + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +namespace RDBDebugger +{ + +enum Column { + Control = 0, + Enable = 1, + Type = 2, + Status = 3, + Location = 4 +}; + + +#define numCols 5 + +static int m_activeFlag = 0; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class BreakpointTableRow : public QTableItem +{ +public: + + BreakpointTableRow(QTable* table, EditType editType, Breakpoint* bp); + ~BreakpointTableRow(); + + bool match (Breakpoint* bp) const; + void reset (); + void setRow(); + + Breakpoint* breakpoint() { return m_breakpoint; } + +private: + void appendEmptyRow(); + +private: + Breakpoint* m_breakpoint; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +BreakpointTableRow::BreakpointTableRow(QTable* parent, EditType editType, + Breakpoint* bp) : + QTableItem(parent, editType, ""), + m_breakpoint(bp) +{ + appendEmptyRow(); + setRow(); +} + +/***************************************************************************/ + +BreakpointTableRow::~BreakpointTableRow() +{ + delete m_breakpoint; +} + +/***************************************************************************/ + +bool BreakpointTableRow::match(Breakpoint* breakpoint) const +{ + return m_breakpoint->match(breakpoint); +} + +/***************************************************************************/ + +void BreakpointTableRow::reset() +{ + m_breakpoint->reset(); + setRow(); +} + +/***************************************************************************/ + +void BreakpointTableRow::appendEmptyRow() +{ + int row = table()->numRows(); + table()->setNumRows(row+1); + + table()->setItem(row, Control, this); + + QCheckTableItem* cti = new QCheckTableItem( table(), ""); + table()->setItem(row, Enable, cti); +} + +/***************************************************************************/ + +void BreakpointTableRow::setRow() +{ + if ( m_breakpoint ) + { + QTableItem *item = table()->item ( row(), Enable ); + Q_ASSERT(item->rtti() == 2); + ((QCheckTableItem*)item)->setChecked(m_breakpoint->isEnabled()); + + QString status=m_breakpoint->statusDisplay(m_activeFlag); + + table()->setText(row(), Status, status); + + QString displayType = m_breakpoint->displayType(); + table()->setText(row(), Location, m_breakpoint->location()); + + if (m_breakpoint->isTemporary()) + displayType = i18n(" temporary"); + + table()->setText(row(), Type, displayType); + table()->adjustColumn(Type); + table()->adjustColumn(Status); + table()->adjustColumn(Location); + } +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +RDBBreakpointWidget::RDBBreakpointWidget(QWidget *parent, const char *name) : + QHBox(parent, name) +{ + QFrame* toolbar = new QFrame( this ); + QVBoxLayout *l = new QVBoxLayout(toolbar, 0, 0); + + toolbar->setFrameStyle( QFrame::ToolBarPanel | QFrame::Plain ); + toolbar->setLineWidth( 0 ); + + m_add = new QToolButton( toolbar, "add breakpoint" ); + m_add->setPixmap ( SmallIcon ( "breakpoint_add" ) ); + QToolTip::add ( m_add, i18n ( "Add empty breakpoint" ) + I18N_NOOP(" <Alt+A>")); + QWhatsThis::add( m_add, i18n("<b>Add empty breakpoint</b><p>Shows a popup menu that allows you to choose " + "the type of breakpoint, then adds a breakpoint of the selected type to the breakpoints list.")); + + m_delete = new QToolButton( toolbar, "delete breakpoint" ); + m_delete->setPixmap ( SmallIcon ( "breakpoint_delete" ) ); + QToolTip::add ( m_delete, i18n ( "Delete selected breakpoint" ) + I18N_NOOP(" <Delete>") ); + QWhatsThis::add( m_delete, i18n("<b>Delete selected breakpoint</b><p>Deletes the selected breakpoint in the breakpoints list.")); + + m_edit = new QToolButton( toolbar, "edit breakpoint" ); + m_edit->setPixmap ( SmallIcon ( "breakpoint_edit" ) ); + QToolTip::add ( m_edit, i18n ( "Edit selected breakpoint" ) + I18N_NOOP(" <Return>") ); + QWhatsThis::add( m_edit, i18n("<b>Edit selected breakpoint</b><p>Allows to edit location, condition and ignore count properties of the selected breakpoint in the breakpoints list.")); + + m_removeAll = new QToolButton( toolbar, "Delete all breakppoints" ); + m_removeAll->setPixmap ( SmallIcon ( "breakpoint_delete_all" ) ); + QToolTip::add ( m_removeAll, i18n ( "Remove all breakpoints" ) ); + QWhatsThis::add( m_removeAll, i18n("<b>Remove all breakpoints</b><p>Removes all breakpoints in the project.")); + + l->addWidget(m_add); + l->addWidget(m_edit); + l->addWidget(m_delete); + l->addWidget(m_removeAll); + QSpacerItem* spacer = new QSpacerItem( 5, 5, QSizePolicy::Minimum, QSizePolicy::Expanding ); + l->addItem(spacer); + + QPopupMenu *addMenu = new QPopupMenu( this ); + addMenu->insertItem( i18n( "File:line" ), BP_TYPE_FilePos ); + addMenu->insertItem( i18n( "Watchpoint" ), BP_TYPE_Watchpoint ); + addMenu->insertItem( i18n( "Catchpoint" ), BP_TYPE_Catchpoint ); + addMenu->insertItem( i18n( "Method()" ), BP_TYPE_Function ); + m_add->setPopup( addMenu ); + m_add->setPopupDelay(1); + + m_table = new RDBTable(0, numCols, this, name); + m_table->setSelectionMode(QTable::SingleRow); + m_table->setShowGrid (false); + m_table->setLeftMargin(0); + m_table->setFocusStyle(QTable::FollowStyle); + + m_table->hideColumn(Control); + m_table->setColumnReadOnly(Type, true); + m_table->setColumnReadOnly(Status, true); + m_table->setColumnWidth( Enable, 20); + + QHeader *header = m_table->horizontalHeader(); + + header->setLabel( Enable, "" ); + header->setLabel( Type, i18n("Type") ); + header->setLabel( Status, i18n("Status") ); + header->setLabel( Location, i18n("Location") ); + + m_table->show(); + + m_ctxMenu = new QPopupMenu( this ); + m_ctxMenu->insertItem( i18n( "Show" ), BW_ITEM_Show ); + m_ctxMenu->insertItem( i18n( "Edit" ), BW_ITEM_Edit ); + m_ctxMenu->insertItem( i18n( "Disable" ), BW_ITEM_Disable ); + m_ctxMenu->insertItem( i18n( "Delete" ), BW_ITEM_Delete ); + + connect( addMenu, SIGNAL(activated(int)), + this, SLOT(slotAddBlankBreakpoint(int)) ); + connect( m_delete, SIGNAL(clicked()), + this, SLOT(slotRemoveBreakpoint()) ); + connect( m_edit, SIGNAL(clicked()), + this, SLOT(slotEditBreakpoint()) ); + connect( m_removeAll, SIGNAL(clicked()), + this, SLOT(slotRemoveAllBreakpoints()) ); + + connect( m_table, SIGNAL(contextMenuRequested(int, int, const QPoint &)), + this, SLOT(slotContextMenuShow(int, int, const QPoint & )) ); + connect( m_ctxMenu, SIGNAL(activated(int)), + this, SLOT(slotContextMenuSelect(int)) ); + + connect( m_table, SIGNAL(doubleClicked(int, int, int, const QPoint &)), + this, SLOT(slotRowDoubleClicked(int, int, int, const QPoint &))); + + connect( m_table, SIGNAL(valueChanged(int, int)), + this, SLOT(slotNewValue(int, int))); + + connect( m_table, SIGNAL(returnPressed()), + this, SLOT(slotEditBreakpoint())); +// connect( m_table, SIGNAL(f2Pressed()), +// this, SLOT(slotEditBreakpoint())); + connect( m_table, SIGNAL(deletePressed()), + this, SLOT(slotRemoveBreakpoint())); + connect( m_table, SIGNAL(insertPressed()), + this, SLOT(slotAddBreakpoint())); +} + +/***************************************************************************/ + +RDBBreakpointWidget::~RDBBreakpointWidget() +{ + delete m_table; +} + +/***************************************************************************/ + +void RDBBreakpointWidget::reset() +{ + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + btr->reset(); + emit publishBPState(*(btr->breakpoint())); + } + } +} + +/***************************************************************************/ + +// When a file is loaded then we need to tell the editor (display window) +// which lines contain a breakpoint. +void RDBBreakpointWidget::slotRefreshBP(const KURL &filename) +{ + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + FilePosBreakpoint* bp = dynamic_cast<FilePosBreakpoint*>(btr->breakpoint()); + if (bp && (bp->fileName() == filename.path())) + emit refreshBPState(*bp); + } + } +} + +/***************************************************************************/ + +BreakpointTableRow* RDBBreakpointWidget::find(Breakpoint *breakpoint) +{ + // NOTE:- The match doesn't have to be equal. Each type of bp + // must decide on the match criteria. + Q_ASSERT (breakpoint); + + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr && btr->match(breakpoint)) + return btr; + } + + return 0; +} + +/***************************************************************************/ + +// The Id is supplied by the debugger +BreakpointTableRow* RDBBreakpointWidget::findId(int dbgId) +{ + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr && btr->breakpoint()->dbgId() == dbgId) + return btr; + } + + return 0; +} + +/***************************************************************************/ + +// The key is a unique number supplied by us +BreakpointTableRow* RDBBreakpointWidget::findKey(int BPKey) +{ + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr && btr->breakpoint()->key() == BPKey) + return btr; + } + + return 0; +} + +/***************************************************************************/ + +BreakpointTableRow* RDBBreakpointWidget::addBreakpoint(Breakpoint *bp) +{ + BreakpointTableRow* btr = + new BreakpointTableRow( m_table, QTableItem::WhenCurrent, bp ); + emit publishBPState(*bp); + return btr; +} + +/***************************************************************************/ + +void RDBBreakpointWidget::removeBreakpoint(BreakpointTableRow* btr) +{ + if (!btr) + return; + + // Pending but the debugger hasn't started processing this bp so + // we can just remove it. + Breakpoint* bp = btr->breakpoint(); + if (bp->isPending() && !bp->isDbgProcessing()) + { + bp->setActionDie(); + emit publishBPState(*bp); + m_table->removeRow(btr->row()); + } + else + { + bp->setPending(true); + bp->setActionClear(true); + emit publishBPState(*bp); + btr->setRow(); + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotToggleBreakpoint(const QString &fileName, int lineNum) +{ + FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1); + + BreakpointTableRow* btr = find(fpBP); + if (btr) + { + delete fpBP; + removeBreakpoint(btr); + } + else + addBreakpoint(fpBP); +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotToggleBreakpointEnabled(const QString &fileName, int lineNum) +{ + FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1); + + BreakpointTableRow* btr = find(fpBP); + delete fpBP; + if (btr) + { + Breakpoint* bp=btr->breakpoint(); + bp->setEnabled(!bp->isEnabled()); + emit publishBPState(*bp); + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotToggleWatchpoint(const QString &varName) +{ + Watchpoint *watchpoint = new Watchpoint(varName, false, true); + BreakpointTableRow* btr = find(watchpoint); + if (btr) + { + removeBreakpoint(btr); + delete watchpoint; + } + else + addBreakpoint(watchpoint); +} + +/***************************************************************************/ + +// The debugger allows us to set pending breakpoints => do it +void RDBBreakpointWidget::slotSetPendingBPs() +{ + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + + if (btr) + { + Breakpoint* bp = btr->breakpoint(); + if (bp->isPending() && !bp->isDbgProcessing() && bp->isValid()) + emit publishBPState(*bp); + } + } +} + +/***************************************************************************/ + +// The debugger is having trouble with this bp - probably because a library +// was unloaded and invalidated a bp that was previously set in the library +// code. Reset the bp so that we can try again later. +void RDBBreakpointWidget::slotUnableToSetBPNow(int BPid) +{ + if (BPid == -1) + reset(); + else + if (BreakpointTableRow *btr = findId(BPid)) + btr->reset(); +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotParseRDBBrkptList(char *str) +{ + // Another example of a not too uncommon occurance + // No breakpoints. + + // Set the new active flag so that after we have read the + // breakpoint list we can trim the breakpoints that have been + // removed (temporary breakpoints do this) + m_activeFlag++; + QRegExp breakpoint_re("(\\d+) [^:]+:\\d+"); + int pos = 0; + + pos = breakpoint_re.search(str, pos); + while (pos >= 0) { + int id = breakpoint_re.cap(1).toInt(); + + BreakpointTableRow* btr = findId(id); + if (btr) + { + Breakpoint *bp = btr->breakpoint(); + bp->setActive(m_activeFlag, id); + btr->setRow(); + emit publishBPState(*bp); + } + + pos += breakpoint_re.matchedLength(); + pos = breakpoint_re.search(str, pos); + } + + str = strstr(str, "Watchpoints:"); + if (str != 0) { + QRegExp watchpoint_re("(\\d+) [^\n]+\n"); + int pos = 0; + + pos = watchpoint_re.search(str, pos); + while (pos >= 0) { + int id = watchpoint_re.cap(1).toInt(); + + BreakpointTableRow* btr = findId(id); + if (btr) + { + Breakpoint *bp = btr->breakpoint(); + bp->setActive(m_activeFlag, id); + btr->setRow(); + emit publishBPState(*bp); + } + + pos += watchpoint_re.matchedLength(); + pos = watchpoint_re.search(str, pos); + } + } + + // Remove any inactive breakpoints. + for ( int row = m_table->numRows()-1; row >= 0 ; row-- ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + Breakpoint* bp = btr->breakpoint(); + if (!(bp->isActive(m_activeFlag))) + removeBreakpoint(btr); + } + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotParseRDBBreakpointSet(char *str, int BPKey) +{ + BreakpointTableRow* btr = findKey(BPKey); + if (!btr) + return; + + Breakpoint *bp = btr->breakpoint(); + bp->setDbgProcessing(false); + + QRegExp breakpoint_re("Set breakpoint (\\d+) at [^:]+:\\d+"); + QRegExp watchpoint_re("Set watchpoint (\\d+)"); + + int id = 0; + if (breakpoint_re.search(str, 0) != -1) { + id = breakpoint_re.cap(1).toInt(); + } else if (watchpoint_re.search(str, 0) != -1) { + id = watchpoint_re.cap(1).toInt(); + } + + if (id > 0) + { + bp->setActive(m_activeFlag, id); + emit publishBPState(*bp); + btr->setRow(); + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotAddBlankBreakpoint(int idx) +{ + BreakpointTableRow* btr = 0; + switch (idx) + { + case BP_TYPE_FilePos: + btr = addBreakpoint(new FilePosBreakpoint("", 0)); + break; + + case BP_TYPE_Watchpoint: + btr = addBreakpoint(new Watchpoint("")); + break; + + case BP_TYPE_Catchpoint: + btr = addBreakpoint(new Catchpoint("")); + break; + + case BP_TYPE_Function: + btr = addBreakpoint(new FunctionBreakpoint("")); + break; + + default: + break; + } + + if (btr) + { + QTableSelection ts; + ts.init(btr->row(), 0); + ts.expandTo(btr->row(), numCols ); + m_table->addSelection(ts); + m_table->editCell(btr->row(), Location, false); + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotRemoveBreakpoint() +{ + int row = m_table->currentRow(); + if ( row != -1) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + removeBreakpoint(btr); + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotRemoveAllBreakpoints() +{ + while (m_table->numRows() > 0) + { + for ( int row = m_table->numRows()-1; row>=0; row-- ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + removeBreakpoint(btr); + } + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotRowDoubleClicked(int row, int col, int btn, const QPoint &) +{ + if ( btn == Qt::LeftButton ) + { +// kdDebug(9012) << "in slotRowSelected row=" << row << endl; + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + FilePosBreakpoint* bp = dynamic_cast<FilePosBreakpoint*>(btr->breakpoint()); + if (bp) + emit gotoSourcePosition(bp->fileName(), bp->lineNum()-1); + + // put the focus back on the clicked item if appropriate + if (col == Location) + m_table->editCell(row, col, false); + } + } +} + +void RDBBreakpointWidget::slotContextMenuShow( int row, int /*col*/, const QPoint &mousePos ) +{ + BreakpointTableRow *btr = (BreakpointTableRow *)m_table->item( row, Control ); + + if (btr != NULL) + { + m_ctxMenu->setItemEnabled( BW_ITEM_Show, (btr->breakpoint( )->type( ) == BP_TYPE_FilePos) ); + if (btr->breakpoint( )->isEnabled( )) + { + m_ctxMenu->changeItem( BW_ITEM_Disable, i18n("Disable") ); + } + else + { + m_ctxMenu->changeItem( BW_ITEM_Disable, i18n("Enable") ); + } + + //m_ctxMenu->popup( mapToGlobal( mousePos ) ); + m_ctxMenu->popup( mousePos ); + } +} + +void RDBBreakpointWidget::slotContextMenuSelect( int item ) +{ + int row, col; + BreakpointTableRow *btr; + Breakpoint *bp; + FilePosBreakpoint *fbp; + + row= m_table->currentRow( ); + if (row == -1) + return; + btr = (BreakpointTableRow *)m_table->item( row, Control ); + if (btr == NULL) + return; + bp = btr->breakpoint( ); + if (bp == NULL) + return; + fbp = dynamic_cast<FilePosBreakpoint*>(bp); + + switch( item ) + { + case BW_ITEM_Show: + if (fbp) + emit gotoSourcePosition(fbp->fileName(), fbp->lineNum()-1); + break; + case BW_ITEM_Edit: + col = m_table->currentColumn( ); + if (col == Location) + m_table->editCell(row, col, false); + break; + case BW_ITEM_Disable: + bp->setEnabled( !bp->isEnabled( ) ); + btr->setRow( ); + emit publishBPState( *bp ); + break; + case BW_ITEM_Delete: + slotRemoveBreakpoint( ); + break; + default: + // oops, check it out! this case is not in sync with the + // m_ctxMenu. Check the enum in the header file. + return; + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotEditRow(int row, int col, const QPoint &) +{ +// kdDebug(9012) << "in slotEditRow row=" << row << endl; + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + if (col == Location) + m_table->editCell(row, col, false); + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotNewValue(int row, int col) +{ +// kdDebug(9012) << "in slotNewValue row=" << row << endl; + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + + if (btr) + { + bool changed=false; + Breakpoint* bp = btr->breakpoint(); + switch (col) + { + + case Enable: + { + QCheckTableItem *item = (QCheckTableItem*)m_table->item ( row, Enable ); + if ( item->isChecked() != bp->isEnabled() ) + { + bp->setEnabled(item->isChecked()); + bp->setPending(true); + bp->setActionModify(true); + changed = true; + } + break; + } + + case Location: + { + if (bp->location() != m_table->text(btr->row(), Location)) + { +// kdDebug(9012) << "Old location [" << bp->location() << "]" << endl; +// kdDebug(9012) << "New location [" << m_table->text(btr->row(), Location) << "]" << endl; + bp->setActionDie(); + emit publishBPState(*bp); + bp->setPending(true); + bp->setActionAdd(true); + bp->setLocation(m_table->text(btr->row(), Location)); + changed = true; + } + break; + } + + case Type: + case Status: + default: + break; + } + + if (changed) + { + btr->setRow(); + emit publishBPState(*bp); + } + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotEditBreakpoint(const QString &fileName, int lineNum) +{ + FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1); + + BreakpointTableRow* btr = find(fpBP); + delete fpBP; + + if (btr) + { + QTableSelection ts; + ts.init(btr->row(), 0); + ts.expandTo(btr->row(), numCols); + m_table->addSelection(ts); + m_table->editCell(btr->row(), Location, false); + } + +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotEditBreakpoint() +{ + m_table->editCell(m_table->currentRow(), Location, false); +} + +/***************************************************************************/ + +void RDBBreakpointWidget::savePartialProjectSession(QDomElement* el) +{ + QDomDocument domDoc = el->ownerDocument(); + if (domDoc.isNull()) + return; + + QDomElement breakpointListEl = domDoc.createElement("breakpointList"); + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = + (BreakpointTableRow *) m_table->item(row, Control); + Breakpoint* bp = btr->breakpoint(); + + QDomElement breakpointEl = + domDoc.createElement("breakpoint"+QString::number(row)); + + breakpointEl.setAttribute("type", bp->type()); + breakpointEl.setAttribute("location", bp->location(false)); + breakpointEl.setAttribute("enabled", bp->isEnabled()); + + breakpointListEl.appendChild(breakpointEl); + } + + if (!breakpointListEl.isNull()) + el->appendChild(breakpointListEl); +} + +/***************************************************************************/ + +void RDBBreakpointWidget::restorePartialProjectSession(const QDomElement* el) +{ + QDomElement breakpointListEl = el->namedItem("breakpointList").toElement(); + if (!breakpointListEl.isNull()) + { + QDomElement breakpointEl; + for (breakpointEl = breakpointListEl.firstChild().toElement(); + !breakpointEl.isNull(); + breakpointEl = breakpointEl.nextSibling().toElement()) + { + Breakpoint* bp=0; + BP_TYPES type = (BP_TYPES) breakpointEl.attribute( "type", "0").toInt(); + switch (type) + { + case BP_TYPE_FilePos: + { + bp = new FilePosBreakpoint("", 0); + break; + } + case BP_TYPE_Watchpoint: + { + bp = new Watchpoint(""); + break; + } + case BP_TYPE_Catchpoint: + { + bp = new Catchpoint(""); + break; + } + case BP_TYPE_Function: + { + bp = new FunctionBreakpoint(""); + break; + } + default: + break; + } + + // Common settings for any type of breakpoint + if (bp) + { + bp->setLocation(breakpointEl.attribute( "location", "")); + bp->setEnabled(breakpointEl.attribute( "enabled", "1").toInt()); + + // Add the bp if we don't already have it. + if (!find(bp)) + addBreakpoint(bp); + else + delete bp; + } + } + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::slotAddBreakpoint( ) +{ + if (m_add->popup()) + { + m_add->popup()->popup(mapToGlobal(this->geometry().topLeft())); + } +} + +/***************************************************************************/ + +void RDBBreakpointWidget::focusInEvent( QFocusEvent */* e*/ ) +{ + m_table->setFocus(); +} + +} + + +#include "rdbbreakpointwidget.moc" diff --git a/languages/ruby/debugger/rdbbreakpointwidget.h b/languages/ruby/debugger/rdbbreakpointwidget.h new file mode 100644 index 00000000..65e6e15b --- /dev/null +++ b/languages/ruby/debugger/rdbbreakpointwidget.h @@ -0,0 +1,120 @@ +/*************************************************************************** + begin : Tue May 13 2003 + copyright : (C) 2003 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. * + * * + ***************************************************************************/ + +#ifndef _RDBBreakpointWidget_H_ +#define _RDBBreakpointWidget_H_ + +#include <qhbox.h> +#include <qpopupmenu.h> + +class QDomElement; +class QToolButton; +class KURL; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +namespace RDBDebugger +{ +class Breakpoint; +class BreakpointTableRow; +class RDBTable; + +class RDBBreakpointWidget : public QHBox +{ + Q_OBJECT + +public: + RDBBreakpointWidget( QWidget* parent=0, const char* name=0 ); + virtual ~RDBBreakpointWidget(); + + void reset(); + + void savePartialProjectSession(QDomElement* el); + void restorePartialProjectSession(const QDomElement* el); + + +public slots: + // Connected to from the editor widget: + void slotToggleBreakpoint(const QString &filename, int lineNum); + void slotToggleBreakpointEnabled(const QString &fileName, int lineNum); + + // Connected to from the variable widget: + void slotToggleWatchpoint(const QString &varName); + + // Connected to from the dbgcontroller: + void slotSetPendingBPs(); + void slotUnableToSetBPNow(int BPNo); + void slotParseRDBBrkptList(char *str); + void slotParseRDBBreakpointSet(char *str, int BPKey); + + void slotRefreshBP(const KURL &filename); + +protected: + enum BW_ITEMS { BW_ITEM_Show, BW_ITEM_Edit, BW_ITEM_Disable, BW_ITEM_Delete }; + virtual void focusInEvent(QFocusEvent *e); + +private slots: + void slotRemoveBreakpoint(); + void slotRemoveAllBreakpoints(); + void slotEditBreakpoint(const QString &fileName, int lineNum); + void slotEditBreakpoint(); + void slotAddBreakpoint(); + void slotAddBlankBreakpoint(int idx); + void slotRowDoubleClicked(int row, int col, int button, const QPoint & mousePos); + void slotContextMenuShow( int row, int col, const QPoint &mousePos ); + void slotContextMenuSelect( int item ); + void slotEditRow(int row, int col, const QPoint & mousePos); + void slotNewValue(int row, int col); + +signals: + void publishBPState(const Breakpoint& brkpt); + void refreshBPState(const Breakpoint& brkpt); + void gotoSourcePosition(const QString &fileName, int lineNum); + void clearAllBreakpoints(); + +private: + BreakpointTableRow* find(Breakpoint *bp); + BreakpointTableRow* findId(int id); + BreakpointTableRow* findKey(int BPKey); + + void setActive(); + BreakpointTableRow* addBreakpoint(Breakpoint *bp); + void removeBreakpoint(BreakpointTableRow* btr); + +private: + RDBTable* m_table; + + QToolButton* m_add; + QToolButton* m_delete; + QToolButton* m_edit; + QToolButton* m_removeAll; + QPopupMenu* m_ctxMenu; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +} + +#endif diff --git a/languages/ruby/debugger/rdbcommand.cpp b/languages/ruby/debugger/rdbcommand.cpp new file mode 100644 index 00000000..98dc3a80 --- /dev/null +++ b/languages/ruby/debugger/rdbcommand.cpp @@ -0,0 +1,81 @@ +/*************************************************************************** + 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 "rdbcommand.h" +#include "breakpoint.h" +#include "variablewidget.h" + +namespace RDBDebugger +{ + + +RDBCommand::RDBCommand(const QCString &setCommand, bool isRunCmd, bool isInfoCmd) + : DbgCommand(setCommand, isRunCmd, isInfoCmd) +{ +// if (prompt_) { +// cmdBuffer_ = QCString().sprintf("set prompt %c%c\n", BLOCK_START, prompt_) + +// command_ + +// idlePrompt_; +// } +} + +/***************************************************************************/ + +RDBCommand::~RDBCommand() +{ +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +RDBItemCommand::RDBItemCommand( VarItem *item, + const QCString &command, + bool isRunCmd) + : RDBCommand(command, isRunCmd, true), + item_(item) +{ +} + +/***************************************************************************/ + +RDBItemCommand::~RDBItemCommand() +{ +} + + +RDBSetBreakpointCommand::RDBSetBreakpointCommand(const QCString &command, int key) + : RDBCommand(command, false, false), + key_(key) +{ +} + +/***************************************************************************/ + +RDBSetBreakpointCommand::~RDBSetBreakpointCommand() +{ +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +} diff --git a/languages/ruby/debugger/rdbcommand.h b/languages/ruby/debugger/rdbcommand.h new file mode 100644 index 00000000..663c8119 --- /dev/null +++ b/languages/ruby/debugger/rdbcommand.h @@ -0,0 +1,99 @@ +/*************************************************************************** + 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. * + * * + ***************************************************************************/ + +#ifndef _RDBCOMMAND_H_ +#define _RDBCOMMAND_H_ + +#include "dbgcommand.h" + +namespace RDBDebugger +{ + +class Breakpoint; +class VarItem; + +// sigh - namespace's don't work on some of the older compilers +enum RDBCmd +{ + CONSTANTS = 'C', + CVARS = 'V', + IVARS = 'I', + LOCALS = 'L' +}; + +#define RUNCMD (true) +#define NOTRUNCMD (false) +#define INFOCMD (true) +#define NOTINFOCMD (false) + +/** + * @author John Birch + */ + +class RDBCommand : public DbgCommand +{ +public: + RDBCommand(const QCString& command, bool isRunCmd=false, bool isInfoCmd=true); + virtual ~RDBCommand(); + +private: + static QCString idlePrompt_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ +class RDBItemCommand : public RDBCommand +{ +public: + RDBItemCommand(VarItem *item, const QCString &command, + bool isRunCmd=false); + virtual ~RDBItemCommand(); + + VarItem *getItem() { return item_; } + +private: + VarItem *item_; +}; + + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ +class RDBSetBreakpointCommand : public RDBCommand +{ +public: + RDBSetBreakpointCommand(const QCString& setCommand, int key); + virtual ~RDBSetBreakpointCommand(); + + int getKey() const { return key_; } + +private: + int key_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +} + +#endif 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" diff --git a/languages/ruby/debugger/rdbcontroller.h b/languages/ruby/debugger/rdbcontroller.h new file mode 100644 index 00000000..2d303218 --- /dev/null +++ b/languages/ruby/debugger/rdbcontroller.h @@ -0,0 +1,192 @@ +/*************************************************************************** + rdbcontroller.h - 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. * + * * + ***************************************************************************/ + +#ifndef _RDBCONTROLLER_H_ +#define _RDBCONTROLLER_H_ + +#include "dbgcontroller.h" + +#include <qcstring.h> +#include <qdom.h> +#include <qobject.h> +#include <qptrlist.h> +#include <qstring.h> +#include <qsocketnotifier.h> + +class KProcess; + +namespace RDBDebugger +{ + +class Breakpoint; +class DbgCommand; +class FramestackWidget; +class VarItem; +class VariableTree; +class STTY; + +/** + * A front end implementation to the ruby command line debugger + * @author jbb + */ + +class RDBController : public DbgController +{ + Q_OBJECT + +public: + RDBController(VariableTree *varTree, FramestackWidget *frameStack, QDomDocument &projectDom); + ~RDBController(); + +protected: + void queueCmd(DbgCommand *cmd, bool executeNext=false); + +private: + void parseProgramLocation (char *buf); + void parseBacktraceList (char *buf); + void parseThreadList (char* buf); + void parseSwitchThread (char* buf); + void parseFrameMove (char *buf); + void parseBreakpointSet (char *buf); + void parseDisplay (char *buf, char * expr); + void parseUpdateDisplay (char *buf); + void parseGlobals (char *buf); + void parseLocals (char type, char *buf); + void parseRequestedData (char *buf); + void parseFrameSelected (char *buf); + + void parse (char *buf); + + void pauseApp(); + void executeCmd (); + void destroyCmds(); + void removeInfoRequests(); + void actOnProgramPause(const QString &msg); + void programNoApp(const QString &msg, bool msgBox); + + void setBreakpoint(const QCString &BPSetCmd, int key); + void clearBreakpoint(const QCString &BPClearCmd); + void modifyBreakpoint(const Breakpoint&); + + void setStateOn(int stateOn) { state_ |= stateOn; } + void setStateOff(int stateOff) { state_ &= ~stateOff; } + bool stateIsOn(int state) { return state_ &state; } + +public slots: + void configure(); + + void slotStart( const QString& shell, const QString& characterCoding, + const QString& run_directory, const QString& debuggee_path, + const QString &application, const QString& run_arguments, + bool show_constants, bool trace_into_ruby ); + //void slotStart(const QString& shell, const QString &application); + + void slotStopDebugger(); + + void slotRun(); + void slotRunUntil(const QString &filename, int lineNum); + void slotStepInto(); + void slotStepOver(); + void slotStepOutOff(); + + void slotBreakInto(); + void slotBPState( const Breakpoint& ); + void slotClearAllBreakpoints(); + + void slotExpandItem(VarItem *parent, const QCString &userRequest); + void slotRubyInspect(const QString &inspectText); + void slotSelectFrame(int frameNo, int threadNo, const QString& frameName); + void slotFetchGlobals(bool fetch); + void slotAddWatchExpression(const QString& expr, bool execute); + void slotRemoveWatchExpression(int displayId); + + void slotUserRDBCmd(const QString&); + +protected slots: + void slotDbgStdout(KProcess *proc, char *buf, int buflen); + void slotDbgStderr(KProcess *proc, char *buf, int buflen); + void slotDbgWroteStdin(KProcess *proc); + void slotDbgProcessExited(KProcess *proc); + + void slotAcceptConnection(int masterSocket); + void slotReadFromSocket(int socket); + +signals: + void acceptPendingBPs (); + void unableToSetBPNow (int BPNo); + void addWatchExpression (const QString&); + +private: + FramestackWidget* frameStack_; + VariableTree* varTree_; + int currentFrame_; + int viewedThread_; + + int stdoutSizeofBuf_; // size of the buffer for holding stdout piped + // from the ruby program + int stdoutOutputLen_; // amount of data in the output buffer + char* stdoutOutput_; // buffer for the output from kprocess + QCString holdingZone_; + + int rdbSizeofBuf_; // size of the output buffer from rdb + int rdbOutputLen_; // amount of data in the rdb buffer + char* rdbOutput_; // buffer for the output from rdb via the Unix socket + + int masterSocket_; // The socket to accept connections + QSocketNotifier* acceptNotifier_; + static QCString unixSocketPath_; // The name of the Unix Domain socket + int socket_; // The socket to read and write to the debuggee + QSocketNotifier* socketNotifier_; + + QPtrList<DbgCommand> cmdList_; + DbgCommand* currentCmd_; + QString currentPrompt_; + + STTY* tty_; + + // Details for starting the ruby debugger process + QString rubyInterpreter_; + QString characterCoding_; + QString runDirectory_; + QString debuggeePath_; + QString application_; + QString runArguments_; + bool showConstants_; + bool traceIntoRuby_; + + // Some state variables + int state_; + bool programHasExited_; + + // Configuration values + QDomDocument &dom; + bool config_forceBPSet_; + bool config_dbgTerminal_; +}; + +} + +#endif diff --git a/languages/ruby/debugger/rdboutputwidget.cpp b/languages/ruby/debugger/rdboutputwidget.cpp new file mode 100644 index 00000000..5e08e116 --- /dev/null +++ b/languages/ruby/debugger/rdboutputwidget.cpp @@ -0,0 +1,171 @@ +// ************************************************************************* +// rdboutputwidget.cpp - description +// ------------------- +// begin : 10th April 2003 +// copyright : (C) 2003 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 "rdboutputwidget.h" +#include "dbgcontroller.h" + +#include <kcombobox.h> +#include <kdebug.h> +#include <kiconloader.h> +#include <klocale.h> + +#include <qlabel.h> +#include <qlayout.h> +#include <qtextedit.h> +#include <qtoolbutton.h> +#include <qtooltip.h> + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +namespace RDBDebugger +{ + +/***************************************************************************/ + +RDBOutputWidget::RDBOutputWidget( QWidget *parent, const char *name) : + QWidget(parent, name), + m_userRDBCmdEditor(0), + m_Interrupt(0), + m_rdbView(0) +{ + + m_rdbView = new QTextEdit (this, name); + m_rdbView->setReadOnly(true); + + QBoxLayout *userRDBCmdEntry = new QHBoxLayout(); + m_userRDBCmdEditor = new KHistoryCombo (this, "rdb-user-cmd-editor"); + + QLabel *label = new QLabel(i18n("&RDB cmd:"), this); + label->setBuddy(m_userRDBCmdEditor); + userRDBCmdEntry->addWidget(label); + + userRDBCmdEntry->addWidget(m_userRDBCmdEditor); + userRDBCmdEntry->setStretchFactor(m_userRDBCmdEditor, 1); + + m_Interrupt = new QToolButton( this, "add breakpoint" ); + m_Interrupt->setSizePolicy ( QSizePolicy ( (QSizePolicy::SizeType)0, + ( QSizePolicy::SizeType)0, + 0, + 0, + m_Interrupt->sizePolicy().hasHeightForWidth()) + ); + m_Interrupt->setPixmap ( SmallIcon ( "player_pause" ) ); + userRDBCmdEntry->addWidget(m_Interrupt); + QToolTip::add ( m_Interrupt, i18n ( "Pause execution of the app to enter rdb commands" ) ); + + QVBoxLayout *topLayout = new QVBoxLayout(this, 2); + topLayout->addWidget(m_rdbView, 10); + topLayout->addLayout(userRDBCmdEntry); + + slotDbgStatus( "", s_dbgNotStarted); + + connect( m_userRDBCmdEditor, SIGNAL(returnPressed()), SLOT(slotRDBCmd()) ); + connect( m_Interrupt, SIGNAL(clicked()), SIGNAL(breakInto())); +} + +/***************************************************************************/ + +RDBOutputWidget::~RDBOutputWidget() +{ + delete m_rdbView; + delete m_userRDBCmdEditor; +} + +/***************************************************************************/ + +void RDBOutputWidget::clear() +{ + if (m_rdbView) + m_rdbView->clear(); +} + +/***************************************************************************/ + +void RDBOutputWidget::slotReceivedStdout(const char* line) +{ + if (strncmp(line, "(rdb:", 5) == 0) + m_rdbView->append(QString("<font color=\"blue\">").append( line ).append("</font>") ); + else + m_rdbView->append(line); +} + +/***************************************************************************/ + +void RDBOutputWidget::slotReceivedStderr(const char* line) +{ + m_rdbView->append(QString("<font color=\"red\">").append( line ).append("</font>") ); +} + +/***************************************************************************/ + +void RDBOutputWidget::slotRDBCmd() +{ + QString RDBCmd(m_userRDBCmdEditor->currentText()); + if (!RDBCmd.isEmpty()) + { + m_userRDBCmdEditor->addToHistory(RDBCmd); + m_userRDBCmdEditor->clearEdit(); + emit userRDBCmd(RDBCmd); + } +} + +/***************************************************************************/ + +void RDBOutputWidget::slotDbgStatus(const QString &, int statusFlag) +{ + if (statusFlag & s_dbgNotStarted) + { + m_Interrupt->setEnabled(false); + m_userRDBCmdEditor->setEnabled(false); + return; + } + + if (statusFlag & s_appBusy) + { + m_Interrupt->setEnabled(true); + m_userRDBCmdEditor->setEnabled(false); + } + else + { + m_Interrupt->setEnabled(false); + m_userRDBCmdEditor->setEnabled(true); + } +} + +/***************************************************************************/ + +void RDBOutputWidget::focusInEvent(QFocusEvent */*e*/) +{ + m_userRDBCmdEditor->setFocus(); +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ +} + + +#include "rdboutputwidget.moc" + diff --git a/languages/ruby/debugger/rdboutputwidget.h b/languages/ruby/debugger/rdboutputwidget.h new file mode 100644 index 00000000..ef466757 --- /dev/null +++ b/languages/ruby/debugger/rdboutputwidget.h @@ -0,0 +1,69 @@ +// ************************************************************************* +// gdboutputwidget.cpp - description +// ------------------- +// begin : 10th April 2003 +// copyright : (C) 2003 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. * +// * * +// ************************************************************************** + +#ifndef _RDBOUTPUTWIDGET_H_ +#define _RDBOUTPUTWIDGET_H_ + +#include <qwidget.h> + +class KHistoryCombo; + +class QTextEdit; +class QToolButton; + +namespace RDBDebugger +{ + +class RDBOutputWidget : public QWidget +{ + Q_OBJECT + +public: + RDBOutputWidget( QWidget *parent=0, const char *name=0 ); + ~RDBOutputWidget(); + + void clear(); + +public slots: + void slotReceivedStdout(const char* line); + void slotReceivedStderr(const char* line); + void slotDbgStatus (const QString &status, int statusFlag); + + void slotRDBCmd(); + +protected: + virtual void focusInEvent(QFocusEvent *e); + +signals: + void userRDBCmd(const QString &cmd); + void breakInto(); + +private: + KHistoryCombo* m_userRDBCmdEditor; + QToolButton* m_Interrupt; + QTextEdit* m_rdbView; +}; + +} + +#endif diff --git a/languages/ruby/debugger/rdbparser.cpp b/languages/ruby/debugger/rdbparser.cpp new file mode 100644 index 00000000..7792acc5 --- /dev/null +++ b/languages/ruby/debugger/rdbparser.cpp @@ -0,0 +1,350 @@ +// ************************************************************************** +// begin : Tue Aug 17 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 "rdbparser.h" +#include "variablewidget.h" + +#include <qregexp.h> + +#include <ctype.h> +#include <stdlib.h> +#include <kdebug.h> + +namespace RDBDebugger +{ + + +// ************************************************************************** + +void RDBParser::parseVariables(LazyFetchItem *parent, char *buf) +{ + static const char *unknown = "?"; + + QString varName; + QCString value; + int pos; + + Q_ASSERT(parent); + if (buf == 0 || strlen(buf) == 0) { + return; + } + + if (buf[0] == 0) { + buf = (char*)unknown; + } + + QRegExp var_re("\\s*([^\\n\\s]+) => ([^\\n]+)"); + QRegExp ref_re("(#<([^:]|::)+:0x[\\da-f]+)\\s*([^=]*)>?"); + QRegExp struct_re("#<struct Struct::(\\w+)"); + + // Look for 'dataitem => value' pairs. For example: + // a => 1 + // m => #<MyClass:0x30093540 @temp={"z"=>"zed", "p"=>"pee"}, @foobar="hello"> + // + pos = var_re.search(buf); + if (pos != -1) { + while (pos != -1) { + varName = var_re.cap(1); + if (ref_re.search(var_re.cap(2)) != -1) { + if (var_re.cap(2).contains("=") > 0) { + value = (ref_re.cap(1) + ">").latin1(); + } else { + // There are no 'name=value' pairs, as in #<Qt::Color:0x0 #ff0000> + value = var_re.cap(2).latin1(); + } + } else if (struct_re.search(var_re.cap(2)) != -1) { + value = (QString("#<Struct::") + struct_re.cap(1) + ">").latin1(); + } else { + value = var_re.cap(2).latin1(); + } + + DataType dataType = determineType((char *) var_re.cap(2).latin1()); + + // 'self' variables don't need to be expandable, as their details are + // already shown in the current frame. So always make them VALUE_TYPE's. + if (varName == "self") { + dataType = VALUE_TYPE; + } + + setItem(parent, varName, dataType, value); + + pos += var_re.matchedLength(); + pos = var_re.search(buf, pos); + } + + return; + } +} + +void RDBParser::parseExpandedVariable(VarItem *parent, char *buf) +{ + DataType dataType; + int pos; + QString varName; + QCString value; + QRegExp ppref_re("(#<([^:]|::)+:0x[\\da-f]+)([^\\n>]*)(>?)"); + + switch (parent->dataType()) { + case REFERENCE_TYPE: + { + // Look for a reference type which has been printed via a 'pp' command, to + // expand its sub items on multiple lines. For example: + // #<MyClass:0x30093540 + // @foobar="hello", + // @sleeper=#<Thread:0x3008fd18 sleep>, + // @temp={"z"=>"zed", "p"=>"pee"}> + // + QRegExp ppvalue_re("\\s*([^\\n\\s=]+)=([^\\n]+)[,>]"); + + pos = ppref_re.search(buf); + if (pos != -1) { + if (ppref_re.cap(4) != "") { + // The value is all on one line, so match against name=value + // pairs which can't have commas in their values + ppvalue_re = QRegExp("\\s*([^\\s=]+)=([^,>]+)([,>])"); + } + + pos = ppvalue_re.search(buf, pos); + + while (pos != -1) { + varName = ppvalue_re.cap(1); + + if (ppref_re.search(ppvalue_re.cap(2)) != -1) { + if (ppvalue_re.cap(2).contains("=") > 0) { + value = (ppref_re.cap(1) + ">").latin1(); + } else { + // There are no 'name=value' pairs, as in #<Qt::Color:0x0 #ff0000> + value = ppvalue_re.cap(2).latin1(); + } + } else { + value = ppvalue_re.cap(2).latin1(); + } + + dataType = determineType((char *) ppvalue_re.cap(2).latin1()); + setItem(parent, varName, dataType, value); + + pos += ppvalue_re.matchedLength(); + pos = ppvalue_re.search(buf, pos); + } + + } + return; + } + + case ARRAY_TYPE: + { + // Look for a array type which has been printed via a 'pp' command, to + // expand its sub items. For example: + // [0]="hello" + // [1]=#"goodbye" + // + QRegExp pparray_re("\\s*([^=]+)=([^\\n]+)\\n"); + + pos = pparray_re.search(buf); + + while (pos != -1) { + varName = pparray_re.cap(1); + + if (ppref_re.search(pparray_re.cap(2)) != -1) { + value = (ppref_re.cap(1) + ">").latin1(); + } else { + value = pparray_re.cap(2).latin1(); + } + + DataType dataType = determineType((char *) pparray_re.cap(2).latin1()); + setItem(parent, varName, dataType, value); + + pos += pparray_re.matchedLength(); + pos = pparray_re.search(buf, pos); + } + + return; + } + + case HASH_TYPE: + { + // Look for a hash type which has been printed via a 'pp' command, to + // expand its sub items. For example: + // ["greeting"]="hello" + // ["farewell"]="goodbye" + // + QRegExp pphash_re("\\s*(\\[[^\\]]+\\])=([^\\n]+)\\n"); + pos = pphash_re.search(buf); + + while (pos != -1) { + varName = pphash_re.cap(1); + value = pphash_re.cap(2).latin1(); + DataType dataType = determineType(value.data()); + setItem(parent, varName, dataType, value); + + pos += pphash_re.matchedLength(); + pos = pphash_re.search(buf, pos); + } + + return; + } + + case STRUCT_TYPE: + { + // Look for a reference type which has been printed via a 'pp' command, to + // expand its sub items. For example: + // #<Struct::Customer + // @foobar="hello", + // @sleeper=#<Thread:0x3008fd18 sleep>, + // @temp={"z"=>"zed", "p"=>"pee"}> + // + QRegExp ppstruct_re("(#<Struct::\\w+)\\s([^\\n>]*)(>?)"); + QRegExp ppvalue_re("\\s*([^\\n\\s=]+)=([^\\n]+)[,>]"); + + pos = ppstruct_re.search(buf); + if (pos != -1) { + if (ppstruct_re.cap(3) != "" && ppvalue_re.search(ppstruct_re.cap(0)) != -1) { + // The line ends with a '>', but we have this case now.. + // If there is only one instance variable, pp puts everything + // on a single line: + // #<Struct::Customer @foobar="hello"> + // So search for '@foobar="hello"', to use as the + // first name=value pair + pos = 0; + } else { + // Mltiple lines with name=value pairs: + // #<Struct::Customer + // @foobar="hello", + pos = ppvalue_re.search(buf, pos); + } + + while (pos != -1) { + varName = ppvalue_re.cap(1); + value = ppvalue_re.cap(2).latin1(); + dataType = determineType(value.data()); + setItem(parent, varName, dataType, value); + + pos += ppvalue_re.matchedLength(); + pos = ppvalue_re.search(buf, pos); + } + + } + return; + } + + case STRING_TYPE: + { + // Look for a long String which has been printed via a 'pp' command, to + // show it as a sequence of 12 bytes slices in hex. For example: + // [0..11]=0x89504e470d0a1a0a0000000d + // [12..23]=0x494844520000001600000016 + // + QRegExp ppstring_re("\\s*(\\[[^\\]]+\\])=([^\\n]+)\\n"); + pos = ppstring_re.search(buf); + + while (pos != -1) { + varName = ppstring_re.cap(1); + value = ppstring_re.cap(2).latin1(); + DataType dataType = determineType(value.data()); + setItem(parent, varName, dataType, value); + + pos += ppstring_re.matchedLength(); + pos = ppstring_re.search(buf, pos); + } + + return; + } + + default: + Q_ASSERT(false); + } + + return; +} + + +// ************************************************************************** + +void RDBParser::setItem(LazyFetchItem *parent, const QString &varName, + DataType dataType, const QCString &value) +{ + VarItem *item = parent->findItem(varName); + if (item == 0) { + item = new VarItem(parent, varName, dataType); + } else { + // The dataType of an item can change, so update it + item->setDataType(dataType); + } + + switch (dataType) { + case HASH_TYPE: + case ARRAY_TYPE: + case REFERENCE_TYPE: + case STRUCT_TYPE: + case STRING_TYPE: + item->setText(VALUE_COLUMN, value); + item->setExpandable(true); + item->update(); + break; + + case COLOR_TYPE: + case VALUE_TYPE: + item->setText(VALUE_COLUMN, value); + item->setExpandable(false); + break; + + default: + break; + } +} + +// ************************************************************************** + +DataType RDBParser::determineType(char *buf) +{ + QRegExp array_re("(Array \\(\\d+ element\\(s\\)\\))"); + QRegExp hash_re("(Hash \\(\\d+ element\\(s\\)\\))"); + QRegExp string_re("(String \\(length \\d+\\))"); + + if (qstrncmp(buf, "#<struct", strlen("#<struct")) == 0) { + return STRUCT_TYPE; + } else if (qstrncmp(buf, "#<Qt::Color:0x", strlen("#<Qt::Color:0x")) == 0) { + return COLOR_TYPE; + } else if (qstrncmp(buf, "#<", strlen("#<")) == 0 && strstr(buf, "=") != 0) { + // An object instance reference is only expandable and a 'REFERENCE_TYPE' + // if it contains an '=' (ie it has at least one '@instance_variable=value'). + // Otherwise, treat it as a 'VALUE_TYPE'. + return REFERENCE_TYPE; + } else if (array_re.search(buf) != -1) { + return ARRAY_TYPE; + } else if (hash_re.search(buf) != -1) { + return HASH_TYPE; + } else if (string_re.search(buf) != -1) { + return STRING_TYPE; + } else if (qstrncmp(buf, "nil", strlen("nil")) == 0) { +// return UNKNOWN_TYPE; + return VALUE_TYPE; + } else { + return VALUE_TYPE; + } +} + + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +} diff --git a/languages/ruby/debugger/rdbparser.h b/languages/ruby/debugger/rdbparser.h new file mode 100644 index 00000000..12bc937e --- /dev/null +++ b/languages/ruby/debugger/rdbparser.h @@ -0,0 +1,41 @@ +/*************************************************************************** + begin : Tue Aug 17 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. * + * * + ***************************************************************************/ + +#ifndef _RDBPARSER_H_ +#define _RDBPARSER_H_ + +#include "variablewidget.h" + +namespace RDBDebugger +{ + +namespace RDBParser +{ + void parseVariables(LazyFetchItem *parent, char *buf); + void parseExpandedVariable(VarItem *parent, char *buf); + DataType determineType(char *buf); + void setItem( LazyFetchItem *parent, const QString &varName, + DataType dataType, const QCString &value ); +} + +} + +#endif diff --git a/languages/ruby/debugger/rdbtable.cpp b/languages/ruby/debugger/rdbtable.cpp new file mode 100644 index 00000000..2f470b2d --- /dev/null +++ b/languages/ruby/debugger/rdbtable.cpp @@ -0,0 +1,62 @@ +/*************************************************************************** +* Copyright (C) 2003 by Alexander Dymo * +* cloudtemple@mksat.net * +* * +* * +* 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 "rdbtable.h" + +namespace RDBDebugger { + +RDBTable::RDBTable(QWidget *parent, const char *name) + : QTable(parent, name) +{ +} + +RDBTable::RDBTable(int nr, int nc, QWidget * parent, const char * name) + : QTable(nr, nc, parent, name) +{ +} + +RDBTable::~RDBTable() +{ +} + +void RDBTable::keyPressEvent( QKeyEvent * e ) +{ + emit keyPressed(e->key()); + + if (e->key() == Key_Return) + emit returnPressed(); + else if (e->key() == Key_F2) + emit f2Pressed(); + else if ((e->text() == QString("a")) && (e->state() == AltButton)) + { + emit insertPressed(); + return; + } + else if ((e->text() == QString("A")) && (e->state() == AltButton)) + { + emit insertPressed(); + return; + } + else if (e->key() == Key_Delete) + emit deletePressed(); + + QTable::keyPressEvent(e); +} + +} + +#include "rdbtable.moc" + diff --git a/languages/ruby/debugger/rdbtable.h b/languages/ruby/debugger/rdbtable.h new file mode 100644 index 00000000..04f47c2b --- /dev/null +++ b/languages/ruby/debugger/rdbtable.h @@ -0,0 +1,45 @@ +/*************************************************************************** +* Copyright (C) 2003 by Alexander Dymo * +* cloudtemple@mksat.net * +* * +* 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. * +***************************************************************************/ +#ifndef RDBDEBUGGERRDBTABLE_H +#define RDBDEBUGGERRDBTABLE_H + +#include <qtable.h> + +namespace RDBDebugger { + +class RDBTable : public QTable +{ +Q_OBJECT +public: + RDBTable(QWidget *parent = 0, const char *name = 0); + RDBTable( int numRows, int numCols, QWidget * parent = 0, const char * name = 0 ); + ~RDBTable(); + + virtual void keyPressEvent ( QKeyEvent * e ); + +signals: + void keyPressed(int key); + + void returnPressed(); + void f2Pressed(); + void insertPressed(); + void deletePressed(); +}; + +} + +#endif + diff --git a/languages/ruby/debugger/stty.cpp b/languages/ruby/debugger/stty.cpp new file mode 100644 index 00000000..44cb3795 --- /dev/null +++ b/languages/ruby/debugger/stty.cpp @@ -0,0 +1,370 @@ +/*************************************************************************** + begin : Mon Sep 13 1999 + copyright : (C) 1999 by John Birch + email : jbb@kdevelop.org + + This code was originally written by Judin Maxim, from the + KDEStudio project. + + It was then updated with later code from konsole (KDE). + + It has also been enhanced with an idea from the code in kdbg + written by Johannes Sixt<Johannes.Sixt@telecom.at> + + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#ifdef __osf__ +#define _XOPEN_SOURCE_EXTENDED +#define O_NDELAY O_NONBLOCK +#endif + +#include <sys/types.h> +#include <sys/ioctl.h> +#include <sys/stat.h> +#include <sys/wait.h> +#include <sys/time.h> +#include <sys/resource.h> + +#ifdef HAVE_SYS_STROPTS_H +#include <sys/stropts.h> +#define _NEW_TTY_CTRL +#endif + +#include <assert.h> +#include <fcntl.h> +#include <grp.h> +#include <stdio.h> +#include <stdlib.h> +#include <signal.h> +#include <termios.h> +#include <time.h> +#include <unistd.h> + +#if defined (_HPUX_SOURCE) +#define _TERMIOS_INCLUDED +#include <bsdtty.h> +#endif + +#include <qintdict.h> +#include <qsocketnotifier.h> +#include <qstring.h> +#include <qfile.h> + +#include <klocale.h> +#include <kstandarddirs.h> +#include <kapplication.h> + +#include "stty.h" + +#define PTY_FILENO 3 +#define BASE_CHOWN "konsole_grantpty" + +namespace RDBDebugger +{ + +static int chownpty(int fd, int grant) +// param fd: the fd of a master pty. +// param grant: 1 to grant, 0 to revoke +// returns 1 on success 0 on fail +{ + void(*tmp)(int) = signal(SIGCHLD,SIG_DFL); + pid_t pid = fork(); + if (pid < 0) { + signal(SIGCHLD,tmp); + return 0; + } + if (pid == 0) { + /* We pass the master pseudo terminal as file descriptor PTY_FILENO. */ + if (fd != PTY_FILENO && dup2(fd, PTY_FILENO) < 0) + ::exit(1); + + QString path = locate("exe", BASE_CHOWN); + execle(QFile::encodeName(path), BASE_CHOWN, grant?"--grant":"--revoke", (void *)0, NULL); + ::exit(1); // should not be reached + } + if (pid > 0) { + int w; + // retry: + int rc = waitpid (pid, &w, 0); + if (rc != pid) + ::exit(1); + + // { // signal from other child, behave like catchChild. + // // guess this gives quite some control chaos... + // Shell* sh = shells.find(rc); + // if (sh) { shells.remove(rc); sh->doneShell(w); } + // goto retry; + // } + signal(SIGCHLD,tmp); + return (rc != -1 && WIFEXITED(w) && WEXITSTATUS(w) == 0); + } + signal(SIGCHLD,tmp); + return 0; //dummy. +} + +// ************************************************************************** + +STTY::STTY(bool ext, const QString &termAppName) + : QObject(), + out(0), + err(0), + ttySlave(""), + pid_(0) +{ + if (ext) { + findExternalTTY(termAppName); + } else { + fout = findTTY(); + if (fout >= 0) { + ttySlave = QString(tty_slave); + out = new QSocketNotifier(fout, QSocketNotifier::Read, this); + connect( out, SIGNAL(activated(int)), this, SLOT(OutReceived(int)) ); + } + } +} + +// ************************************************************************** + +STTY::~STTY() +{ + if (pid_) + ::kill(pid_, SIGTERM); + + if (out) { + ::close(fout); + delete out; + } + + // if ( err ) + // { + // ::close( ferr ); + // delete err; + // } +} + +// ************************************************************************** + +int STTY::findTTY() +{ + int ptyfd = -1; + bool needGrantPty = TRUE; + + // Find a master pty that we can open //////////////////////////////// + +#ifdef __sgi__ + ptyfd = open("/dev/ptmx",O_RDWR); + if (ptyfd < 0) { + perror("Can't open a pseudo teletype"); + return(-1); + } + strncpy(tty_slave, ptsname(ptyfd), 50); + grantpt(ptyfd); + unlockpt(ptyfd); + needGrantPty = FALSE; +#endif + + // first we try UNIX PTY's +#ifdef TIOCGPTN + strcpy(pty_master,"/dev/ptmx"); + strcpy(tty_slave,"/dev/pts/"); + ptyfd = open(pty_master,O_RDWR); + if (ptyfd >= 0) { // got the master pty + int ptyno; + if (ioctl(ptyfd, TIOCGPTN, &ptyno) == 0) { + struct stat sbuf; + sprintf(tty_slave,"/dev/pts/%d",ptyno); + if (stat(tty_slave,&sbuf) == 0 && S_ISCHR(sbuf.st_mode)) + needGrantPty = FALSE; + else { + close(ptyfd); + ptyfd = -1; + } + } else { + close(ptyfd); + ptyfd = -1; + } + } +#endif + +#if defined(_SCO_DS) || defined(__USLC__) /* SCO OSr5 and UnixWare */ + if (ptyfd < 0) { + for (int idx = 0; idx < 256; idx++) + { sprintf(pty_master, "/dev/ptyp%d", idx); + sprintf(tty_slave, "/dev/ttyp%d", idx); + if (access(tty_slave, F_OK) < 0) { idx = 256; break; } + if ((ptyfd = open (pty_master, O_RDWR)) >= 0) + { if (access (tty_slave, R_OK|W_OK) == 0) break; + close(ptyfd); ptyfd = -1; + } + } + } +#endif + if (ptyfd < 0) { /// \FIXME Linux, Trouble on other systems? + for (const char* s3 = "pqrstuvwxyzabcde"; *s3 != 0; s3++) { + for (const char* s4 = "0123456789abcdef"; *s4 != 0; s4++) { + sprintf(pty_master,"/dev/pty%c%c",*s3,*s4); + sprintf(tty_slave,"/dev/tty%c%c",*s3,*s4); + if ((ptyfd = open(pty_master, O_RDWR)) >= 0) { + if (geteuid() == 0 || access(tty_slave, R_OK|W_OK) == 0) + break; + + close(ptyfd); + ptyfd = -1; + } + } + + if (ptyfd >= 0) + break; + } + } + + if (ptyfd >= 0) { + if (needGrantPty && !chownpty(ptyfd, TRUE)) { + fprintf(stderr,"kdevelop: chownpty failed for device %s::%s.\n",pty_master,tty_slave); + fprintf(stderr," : This means the session can be eavesdroped.\n"); + fprintf(stderr," : Make sure konsole_grantpty is installed and setuid root.\n"); + } + + ::fcntl(ptyfd, F_SETFL, O_NDELAY); +#ifdef TIOCSPTLCK + int flag = 0; + ioctl(ptyfd, TIOCSPTLCK, &flag); // unlock pty +#endif + } + + return ptyfd; +} + +// ************************************************************************** + +void STTY::OutReceived(int f) +{ + char buf[1024]; + int n; + + // read until socket is empty. We shouldn't be receiving a continuous + // stream of data, so the loop is unlikely to cause problems. + while ((n = ::read(f, buf, sizeof(buf)-1)) > 0) { + *(buf+n) = 0; // a standard string + if ( f == fout ) + emit OutOutput(buf); + else + emit ErrOutput(buf); + } +} + +// ************************************************************************** + +#define FIFO_FILE "/tmp/debug_tty.XXXXXX" + +bool STTY::findExternalTTY(const QString &termApp) +{ + QString appName(termApp.isEmpty() ? QString("xterm") : termApp); + + char fifo[] = FIFO_FILE; + int fifo_fd; + if ((fifo_fd = mkstemp(fifo)) == -1) + return false; + + ::close(fifo_fd); + ::unlink(fifo); + + // create a fifo that will pass in the tty name +#ifdef HAVE_MKFIFO + if (::mkfifo(fifo, S_IRUSR|S_IWUSR) < 0) +#else + if (::mknod(fifo, S_IFIFO | S_IRUSR|S_IWUSR, 0) < 0) +#endif + return false; + + int pid = ::fork(); + if (pid < 0) { // No process + ::unlink(fifo); + return false; + } + + if (pid == 0) { // child process + /* + * Spawn a console that in turn runs a shell script that passes us + * back the terminal name and then only sits and waits. + */ + + const char* prog = appName.latin1(); + QString script = QString("tty>") + QString(fifo) + + QString(";" // fifo name + "trap \"\" INT QUIT TSTP;" // ignore various signals + "exec<&-;exec>&-;" // close stdin and stdout + "while :;do sleep 3600;done"); + const char* scriptStr = script.latin1(); + const char* end = 0; + + if ( termApp == "konsole" ) + { + ::execlp( prog, prog, + "-caption", i18n("kdevelop: Debug application console").local8Bit().data(), + "-e", "sh", + "-c", scriptStr, + end); + } + else + { + ::execlp( prog, prog, + "-e", "sh", + "-c", scriptStr, + end); + } + + // Should not get here, as above should always work + ::exit(1); + } + + // parent process + if (pid <= 0) + ::exit(1); + + // Open the communication between us (the parent) and the + // child (the process running on a tty console) + fifo_fd = ::open(fifo, O_RDONLY); + if (fifo_fd < 0) + return false; + + // Get the ttyname from the fifo buffer that the child process + // has sent. + char ttyname[50]; + int n = ::read(fifo_fd, ttyname, sizeof(ttyname)-sizeof(char)); + + ::close(fifo_fd); + ::unlink(fifo); + + // No name?? + if (n <= 0) + return false; + + // remove whitespace + ttyname[n] = 0; + if (char* newline = strchr(ttyname, '\n')) + *newline = 0; // clobber the new line + + ttySlave = ttyname; + pid_ = pid; + + return true; +} + +} + +// ************************************************************************** +#include "stty.moc" diff --git a/languages/ruby/debugger/stty.h b/languages/ruby/debugger/stty.h new file mode 100644 index 00000000..31c8fbfe --- /dev/null +++ b/languages/ruby/debugger/stty.h @@ -0,0 +1,71 @@ +/*************************************************************************** + begin : Mon Sep 13 1999 + copyright : (C) 1999 by John Birch + email : jbb@kdevelop.org + + This code was originally written by Judin Maxim, from the + KDEStudio project. + + It was then updated with later code from konsole (KDE). + + It has also been enhanced with an idea from the code in kdbg + written by Johannes Sixt<Johannes.Sixt@telecom.at> + + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ + +#ifndef _STTY_H_ +#define _STTY_H_ + +class QSocketNotifier; + +#include <qobject.h> +#include <qstring.h> + +namespace RDBDebugger +{ + +class STTY : public QObject +{ + Q_OBJECT + +public: + STTY(bool ext=false, const QString &termAppName=QString()); + ~STTY(); + + QString getSlave() { return ttySlave; }; + +private slots: + void OutReceived(int); + +signals: + void OutOutput(const char *); + void ErrOutput(const char*); + +private: + int findTTY(); + bool findExternalTTY(const QString &termApp); + +private: + int fout; + int ferr; + QSocketNotifier *out; + QSocketNotifier *err; + QString ttySlave; + int pid_; + + char pty_master[50]; // "/dev/ptyxx" | "/dev/ptmx" + char tty_slave[50]; // "/dev/ttyxx" | "/dev/pts/########..." +}; + +} + +#endif diff --git a/languages/ruby/debugger/variablewidget.cpp b/languages/ruby/debugger/variablewidget.cpp new file mode 100644 index 00000000..0dbdce9a --- /dev/null +++ b/languages/ruby/debugger/variablewidget.cpp @@ -0,0 +1,1018 @@ +// ************************************************************************** +// 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 "variablewidget.h" +#include "rdbparser.h" +#include "rdbcommand.h" + +#include <kdebug.h> +#include <kpopupmenu.h> +#include <klineedit.h> +#include <kdeversion.h> + +#include <qheader.h> +#include <qlabel.h> +#include <qlayout.h> +#include <qhbox.h> +#include <qpainter.h> +#include <qpushbutton.h> +#include <qregexp.h> +#include <qcursor.h> +#include <klocale.h> + +#include <qpoint.h> +#include <qclipboard.h> +#include <kapplication.h> + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +namespace RDBDebugger +{ + +VariableWidget::VariableWidget(QWidget *parent, const char *name) + : QWidget(parent, name) +{ + varTree_ = new VariableTree(this); + QLabel *label = new QLabel(i18n("E&xpression to watch:"), this); + + QHBox *watchEntry = new QHBox( this ); + watchVarEditor_ = new KHistoryCombo( watchEntry, "var-to-watch editor"); + label->setBuddy(watchVarEditor_); + + QPushButton *addButton = new QPushButton(i18n("&Add"), watchEntry ); + addButton->adjustSize(); + addButton->setFixedWidth(addButton->width()); + + QBoxLayout * vbox = new QVBoxLayout(); + vbox->addWidget( label ); + vbox->addWidget( watchEntry ); + + QVBoxLayout *topLayout = new QVBoxLayout(this, 2); + topLayout->addWidget(varTree_, 10); + topLayout->addLayout( vbox ); + + connect( addButton, SIGNAL(clicked()), SLOT(slotAddWatchExpression()) ); + connect( watchVarEditor_, SIGNAL(returnPressed()), SLOT(slotAddWatchExpression()) ); +} + + +// ************************************************************************** + +void VariableWidget::setEnabled(bool bEnabled) +{ + QWidget::setEnabled(bEnabled); + if (bEnabled && parentWidget() != 0) { + varTree_->setColumnWidth(0, parentWidget()->width()/2); + } +} +// ************************************************************************** + +void VariableWidget::slotAddWatchExpression() +{ + QString watchVar(watchVarEditor_->currentText()); + if (!watchVar.isEmpty()) { + slotAddWatchExpression(watchVar); + } +} + +// ************************************************************************** + +void VariableWidget::slotAddWatchExpression(const QString &ident) +{ + if (!ident.isEmpty()) { + watchVarEditor_->addToHistory(ident); + varTree_->slotAddWatchExpression(ident); + watchVarEditor_->clearEdit(); + } +} + +// ************************************************************************** + +void VariableWidget::focusInEvent(QFocusEvent */*e*/) +{ + varTree_->setFocus(); +} + +void VariableWidget::restorePartialProjectSession(const QDomElement* el) +{ + varTree_->watchRoot()->restorePartialProjectSession(el); +} + +void VariableWidget::savePartialProjectSession(QDomElement* el) +{ + varTree_->watchRoot()->savePartialProjectSession(el); +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +VariableTree::VariableTree(VariableWidget *parent, const char *name) + : KListView(parent, name), + QToolTip( viewport() ), + activationId_(0), + currentThread_(-1), + selectedFrame_(0), + watchRoot_(0), + globalRoot_(0) +{ + setRootIsDecorated(true); + setAllColumnsShowFocus(true); + setColumnWidthMode(0, Manual); + setSorting(VAR_NAME_COLUMN); + QListView::setSelectionMode(QListView::Single); + + addColumn(i18n("Variable"), 100 ); + addColumn(i18n("Value"), 100 ); + + connect( this, SIGNAL(contextMenu(KListView*, QListViewItem*, const QPoint&)), + SLOT(slotContextMenu(KListView*, QListViewItem*)) ); + + connect( this, SIGNAL(pressed(QListViewItem*)), + this, SLOT(slotPressed(QListViewItem*)) ); + + watchRoot_ = new WatchRoot(this); +} + +// ************************************************************************** + +VariableTree::~VariableTree() +{ +} + +// ************************************************************************** + +void VariableTree::clear() +{ + QListViewItem *sibling = firstChild(); + while (sibling != 0) { + QListViewItem * current = sibling; + sibling = sibling->nextSibling(); + if (current->rtti() != RTTI_WATCH_ROOT) { + delete current; + } + } + + globalRoot_ = 0; + selectedFrame_ = 0; + return; +} + +// ************************************************************************** + +void VariableTree::slotContextMenu(KListView *, QListViewItem *item) +{ + if (item == 0) + return; + + setSelected(item, true); // Need to select this item. + + if (item->parent() != 0) { + KPopupMenu popup(this); + popup.insertTitle(item->text(VAR_NAME_COLUMN)); + int idRemoveWatch = -2; + if (item->rtti() == RTTI_WATCH_VAR_ITEM) { + idRemoveWatch = popup.insertItem( i18n("Remove Watch Expression") ); + } + + int idCopyToClipboard = popup.insertItem( i18n("Copy to Clipboard") ); + int res = popup.exec(QCursor::pos()); + + if (res == idRemoveWatch) { + emit removeWatchExpression(((WatchVarItem*)item)->displayId()); + delete item; + } else if (res == idCopyToClipboard) { + QClipboard *qb = KApplication::clipboard(); + QString text = "{ \"" + item->text( VAR_NAME_COLUMN ) + "\", " + + "\"" + item->text( VALUE_COLUMN ) + "\" }"; + + qb->setText( text, QClipboard::Clipboard ); + } + } +} + +/***************************************************************************/ + +void VariableTree::setSelected(QListViewItem * item, bool selected) +{ + // Save the last selected VarFrameRoot for slotPressed() to restore + if (item->rtti() == RTTI_VAR_FRAME_ROOT && selected) { + selectedFrame_ = (VarFrameRoot *) item; + } + + QListView::setSelected(item, selected); +} + +/***************************************************************************/ + +// Makes sure that only VarFrameRoot items can be selected +void VariableTree::slotPressed(QListViewItem * item) +{ + if (item == 0) { + return; + } + + while (item->rtti() == RTTI_VAR_ITEM) { + item = item->parent(); + } + + if ( item->rtti() == RTTI_GLOBAL_ROOT + || item->rtti() == RTTI_WATCH_ROOT + || item->rtti() == RTTI_WATCH_VAR_ITEM ) + { + if (selectedFrame_ != 0) { + setSelected(selectedFrame_, true); + } + return; + } + + if (item->rtti() == RTTI_VAR_FRAME_ROOT) { + VarFrameRoot * frame = (VarFrameRoot*) item; + emit selectFrame(frame->frameNo(), frame->threadNo()); + } + + return; +} + +// ************************************************************************** + +void VariableTree::prune() +{ + QListViewItem *child = firstChild(); + + while (child != 0) { + QListViewItem *nextChild = child->nextSibling(); + + // Only prune var frames, not the watch or global root + if (child->rtti() == RTTI_VAR_FRAME_ROOT) { + if (((VarFrameRoot*) child)->isActive()) { + if (child->isOpen()) { + ((VarFrameRoot*) child)->prune(); + } + } else { + delete child; + } + } + + child = nextChild; + } +} + +// ************************************************************************** + +// The debugger has moved onto the next program pause, so invalidate +// everything in the Variable Tree +void VariableTree::nextActivationId() +{ + activationId_++; + globalRoot()->setActivationId(); + watchRoot()->setActivationId(); + // ..but that's only the Watch and Global roots +} + +// ************************************************************************** + +// VarFrameRoot frames in the Variable Tree from the previous program pause, +// are set active here. Notified by the Frame Stack widget when it parses the +// backtrace from the 'where' command after a pause. +// +// After that, any frames which aren't marked as active must have gone +// out of scope and will end up pruned. +void VariableTree::slotFrameActive(int frameNo, int threadNo, const QString& frameName) +{ + VarFrameRoot * frame = findFrame(frameNo, threadNo); + if (frameNo == 1) { + // If the current frame 1 doesn't exist, create it + if (frame == 0) { + frame = new VarFrameRoot(this, frameNo, threadNo); + } + + frame->setFrameName(frameName); + } + + if (frame != 0 && frame->text(VAR_NAME_COLUMN) == frameName) { + frame->setActivationId(); + } +} + +// ************************************************************************** + +bool VariableTree::schedule() +{ + QListViewItem * child = firstChild(); + VarFrameRoot * frame = 0; + + while (child != 0) { + if (child->rtti() == RTTI_VAR_FRAME_ROOT) { + frame = (VarFrameRoot *) child; + Q_ASSERT( !frame->isWaitingForData() ); + + if (frame->needsVariables()) { + if (QApplication::overrideCursor() == 0) { + QApplication::setOverrideCursor(QCursor(Qt::WaitCursor)); + } + + // Tell the controller to fetch the variable values + emit selectFrame(frame->frameNo(), frame->threadNo()); + return true; + } + } + + child = child->nextSibling(); + } + + frame = findFrame(1, currentThread_); + Q_ASSERT( frame != 0 ); + Q_ASSERT( !frame->needsVariables() ); + + // All over, nothing left to fetch. + // Return to frame 1, and prune the inactive items + // from the variable tree.. + QApplication::restoreOverrideCursor(); + emit selectFrame(1, currentThread_); + prune(); + + return false; +} + +// ************************************************************************** + +void VariableTree::slotAddWatchExpression(const QString &watchVar) +{ + new WatchVarItem(watchRoot(), watchVar, UNKNOWN_TYPE); + emit addWatchExpression(watchVar, true); +} + + +// ************************************************************************** + +void VariableTree::setFetchGlobals(bool fetch) +{ + emit fetchGlobals(fetch); +} + +// ************************************************************************** + +VarFrameRoot *VariableTree::findFrame(int frameNo, int threadNo) const +{ + // frames only exist on the top level so we only need to + // check the siblings + QListViewItem *sibling = firstChild(); + while (sibling != 0) { + if ( sibling->rtti() == RTTI_VAR_FRAME_ROOT + && ((VarFrameRoot*) sibling)->frameNo() == frameNo + && ((VarFrameRoot*) sibling)->threadNo() == threadNo ) + { + return (VarFrameRoot*) sibling; + } + + sibling = sibling->nextSibling(); + } + + return 0; +} + +// ************************************************************************** + +WatchRoot *VariableTree::watchRoot() +{ + return watchRoot_; +} + +// ************************************************************************** + +GlobalRoot *VariableTree::globalRoot() +{ + if (globalRoot_ == 0) { + globalRoot_ = new GlobalRoot(this); + } + + return globalRoot_; +} + +// ************************************************************************** + +// Watch variables can be added before the start of a debugging session, +// so tell the controller about any already in the tree at start. +void VariableTree::resetWatchVars() +{ + for (QListViewItem *child = watchRoot()->firstChild(); child != 0; child = child->nextSibling()) { + ((WatchVarItem*) child)->setDisplayId(-1); + emit addWatchExpression(child->text(VAR_NAME_COLUMN), false); + } +} + +// ************************************************************************** + +void VariableTree::maybeTip(const QPoint &p) +{ + VarItem * item = dynamic_cast<VarItem*>( itemAt(p) ); + if (item != 0) { + QRect r = itemRect(item); + if (r.isValid()) { + tip(r, item->tipText()); + } + } +} + + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +LazyFetchItem::LazyFetchItem(VariableTree *parent) + : KListViewItem(parent), + activationId_(0), + waitingForData_(false) +{ + setActivationId(); +} + +// ************************************************************************** + +LazyFetchItem::LazyFetchItem(LazyFetchItem *parent) + : KListViewItem(parent), + activationId_(0), + waitingForData_(false) +{ + setActivationId(); +} + +// ************************************************************************** + +LazyFetchItem::~LazyFetchItem() +{ +} + +// ************************************************************************** + +void LazyFetchItem::paintCell(QPainter *p, const QColorGroup &cg, + int column, int width, int align) +{ + if (p == 0) { + return; + } + + // make toplevel item (watch and frame items) names bold + if (column == VAR_NAME_COLUMN && parent() == 0) { + QFont f = p->font(); + f.setBold(true); + p->setFont(f); + } + + QListViewItem::paintCell( p, cg, column, width, align ); +} + +// ************************************************************************** + +VarItem *LazyFetchItem::findItem(const QString &name) const +{ + QListViewItem *child = firstChild(); + + // Check the siblings on this branch + while (child != 0) { + if (child->text(VAR_NAME_COLUMN) == name) { + return (VarItem*) child; + } + + child = child->nextSibling(); + } + + return 0; +} + +// ************************************************************************** + +void LazyFetchItem::prune() +{ + QListViewItem *child = firstChild(); + + while (child != 0) { + LazyFetchItem *item = (LazyFetchItem*) child; + child = child->nextSibling(); + // Never prune a branch if we are waiting on data to arrive. + if (!waitingForData_) { + if (item->isActive()) { + item->prune(); + } else { + delete item; + } + } + } +} + + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +VarItem::VarItem(LazyFetchItem *parent, const QString &varName, DataType dataType) + : LazyFetchItem (parent), + cache_(QCString()), + dataType_(dataType), + highlight_(false) +{ + setText(VAR_NAME_COLUMN, varName); + setSelectable(false); + + // Order the VarItems so that globals are first, then + // constants, class variables, instance variables and + // finally local variables + + // Matches either an array element or a string slice, + // Order on the array index or the first number in the + // range specifying the slice. + QRegExp arrayelement_re("\\[(\\d+)(\\.\\.\\d+)?\\]"); + key_ = varName; + + if (arrayelement_re.search(varName) != -1) { + key_.sprintf("%.6d", arrayelement_re.cap(1).toInt()); + } else if (key_.startsWith("$")) { + key_.prepend("1001"); // Global variable + } else if (QRegExp("^[A-Z]").search(varName) != -1) { + key_.prepend("1002"); // Constant + } else if (key_.startsWith("@@")) { + key_.prepend("1003"); // Class variable + } else if (key_.startsWith("@")) { + key_.prepend("1004"); // Instance variable + } else { + key_.prepend("1005"); // Local variable or parameter + } + +// kdDebug(9012) << " ### VarItem::VarItem *CONSTR* " << varName << endl; +} + +// ************************************************************************** + +VarItem::~VarItem() +{ +} + +QString VarItem::key(int /*column*/, bool /*ascending*/) const +{ + return key_; +} + +// ************************************************************************** + +// Returns the path of a ruby item. If it is an instance variable, assume +// that there is an attr_accessor method for it. +// For example, @foobar within instance obj is accessed as obj.foobar. +// But don't strip off the @ for an instance variable with no path, +// and leave a plain '@foobar' as it is. +QString VarItem::fullName() const +{ + QString itemName = text(VAR_NAME_COLUMN); + QString vPath(""); + const VarItem *item = this; + + if (item->parent()->rtti() != RTTI_VAR_ITEM) { + return itemName; + } + + // This stops at the root item (FrameRoot or GlobalRoot) + while (item->rtti() == RTTI_VAR_ITEM) { + QString itemName = item->text(VAR_NAME_COLUMN); + + if (vPath.startsWith("[")) { + // If it's a Hash or an Array, then just insert the value. As + // in adding '[0]' to foo.bar to give foo.bar[0] + vPath.prepend(itemName); + } else { + if (vPath.isEmpty()) { + vPath = itemName; + } else { + vPath.prepend(itemName + "."); + } + } + item = (VarItem*) item->parent(); + } + + // Change 'self.@foobar' to '@foobar' + vPath.replace(QRegExp("^self\\.@"), "@"); + + // Use instance_variable_get() to access any '@var's in the middle of a path + QRegExp re_instance_var("\\.(@[^\\[.]+)"); + int pos = re_instance_var.search(vPath); + while (pos != -1) { + vPath.replace( pos, + re_instance_var.matchedLength(), + QString(".instance_variable_get(:") + re_instance_var.cap(1) + ")" ); + pos = re_instance_var.search(vPath, pos); + } + + return vPath; +} + +// ************************************************************************** + +void VarItem::setText(int column, const QString &data) +{ + setActivationId(); + + if (column == VALUE_COLUMN) { + highlight_ = (!text(VALUE_COLUMN).isEmpty() && text(VALUE_COLUMN) != data); + } + + QListViewItem::setText(column, data); + repaint(); +} + +// ************************************************************************** + +void VarItem::expandValue(char *buf) +{ + LazyFetchItem::stopWaitingForData(); + RDBParser::parseExpandedVariable(this, buf); +} + +// ************************************************************************** + +void VarItem::setOpen(bool open) +{ + QListViewItem::setOpen(open); + + Q_ASSERT( dataType_ == REFERENCE_TYPE + || dataType_ == ARRAY_TYPE + || dataType_ == HASH_TYPE + || dataType_ == STRING_TYPE + || dataType_ == STRUCT_TYPE ); + + update(); + return; +} + +// ************************************************************************** + +void VarItem::update() +{ + if (isOpen()) { + startWaitingForData(); +// emit ((VariableTree*)listView())->expandItem(this, fullName().latin1()); + ((VariableTree*)listView())->expandItem(this, fullName().latin1()); + } + + return; +} + +// ************************************************************************** + +DataType VarItem::dataType() const +{ + return dataType_; +} + +// ************************************************************************** + +void VarItem::setDataType(DataType dataType) +{ + dataType_ = dataType; +} + +// ************************************************************************** + +// Overridden to highlight the changed items +void VarItem::paintCell(QPainter *p, const QColorGroup &cg, + int column, int width, int align) +{ + if (p == 0) { + return; + } + + if (column == VALUE_COLUMN) { + // Show color values as colors, and make the text color the same + // as the base color + if (dataType_ == COLOR_TYPE) { + QRegExp color_re("\\s(#.*)>"); + + if (color_re.search(text(column)) != -1) { + QColorGroup color_cg( cg.foreground(), cg.background(), + cg.light(), cg.dark(), cg.mid(), + QColor(color_re.cap(1)), QColor(color_re.cap(1)) ); + QListViewItem::paintCell(p, color_cg, column, width, align); + return; + } + } + + // Highlight recently changed items in red + if (highlight_) { + QColorGroup hl_cg( cg.foreground(), cg.background(), + cg.light(), cg.dark(), cg.mid(), + red, cg.base() ); + QListViewItem::paintCell(p, hl_cg, column, width, align); + return; + } + } + + QListViewItem::paintCell(p, cg, column, width, align); + return; +} + +// ************************************************************************** + +QString VarItem::tipText() const +{ + const unsigned int MAX_TOOLTIP_SIZE = 70; + QString tip = text(VALUE_COLUMN); + + if (tip.length() < MAX_TOOLTIP_SIZE) { + return tip; + } else { + return tip.mid(0, MAX_TOOLTIP_SIZE - 1) + " [...]"; + } +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +VarFrameRoot::VarFrameRoot(VariableTree *parent, int frameNo, int threadNo) + : LazyFetchItem(parent), + needsVariables_(true), + frameNo_(frameNo), + threadNo_(threadNo), + cache_("") +{ + setExpandable(true); +} + +// ************************************************************************** + +VarFrameRoot::~VarFrameRoot() +{ +} + +// ************************************************************************** + +void VarFrameRoot::addLocals(char *variables) +{ + cache_.append(variables); +} + +// ************************************************************************** + +void VarFrameRoot::setLocals() +{ + RDBParser::parseVariables(this, cache_.data()); + cache_ = ""; + needsVariables_ = false; + stopWaitingForData(); + prune(); + + return; +} + +// ************************************************************************** + +// Override setOpen so that we can decide what to do when we do change +// state. +void VarFrameRoot::setOpen(bool open) +{ + bool localsViewChanged = (isOpen() != open); + QListViewItem::setOpen(open); + + if (localsViewChanged) { + ((VariableTree*)listView())->selectFrame(frameNo_, threadNo_); + } + + return; +} + +void VarFrameRoot::setFrameName(const QString &frameName) +{ + setText(VAR_NAME_COLUMN, frameName); + setText(VALUE_COLUMN, ""); + + return; +} + +void VarFrameRoot::setActivationId() +{ + LazyFetchItem::setActivationId(); + stopWaitingForData(); + needsVariables_ = true; + cache_ = ""; +} + +bool VarFrameRoot::needsVariables() const +{ + return ( text(VAR_NAME_COLUMN).contains("try_initialize") == 0 + && isOpen() + && !isWaitingForData() + && needsVariables_ ); +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + + +GlobalRoot::GlobalRoot(VariableTree *parent) + : LazyFetchItem(parent) +{ + setText(0, i18n("Global")); + setExpandable(true); + setOpen(false); + setSelectable(false); +} + +// ************************************************************************** + +GlobalRoot::~GlobalRoot() +{ +} + +// ************************************************************************** + +void GlobalRoot::setGlobals(char * globals) +{ + setActivationId(); + RDBParser::parseVariables(this, globals); + + return; +} + +// ************************************************************************** + +void GlobalRoot::setOpen(bool open) +{ + bool globalsViewChanged = (isOpen() != open); + QListViewItem::setOpen(open); + + if (globalsViewChanged) { + ((VariableTree*)listView())->setFetchGlobals(isOpen()); + } + + return; +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +WatchVarItem::WatchVarItem( LazyFetchItem *parent, const QString &varName, DataType dataType, int displayId ) + : VarItem(parent, varName, dataType), + displayId_(displayId) +{ +} + +// ************************************************************************** + +WatchVarItem::~WatchVarItem() +{ +} + +// ************************************************************************** + +void WatchVarItem::setDisplayId(int id) +{ + displayId_ = id; +} + +// ************************************************************************** + +int WatchVarItem::displayId() +{ + return displayId_; +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +WatchRoot::WatchRoot(VariableTree *parent) + : LazyFetchItem(parent) +{ + setText(VAR_NAME_COLUMN, i18n("Watch")); + setOpen(true); + setSelectable(false); +} + +// ************************************************************************** + +WatchRoot::~WatchRoot() +{ +} + +// ************************************************************************** + +// Sets the initial value of a new Watch item, along with the +// display id +void WatchRoot::setWatchExpression(char * buf, char * expression) +{ + QString expr(expression); + QRegExp display_re("^(\\d+):\\s([^\n]+)\n"); + + for ( QListViewItem *child = firstChild(); + child != 0; + child = child->nextSibling() ) + { + WatchVarItem *varItem = (WatchVarItem*) child; + if ( varItem->text(VAR_NAME_COLUMN) == expr + && varItem->displayId() == -1 + && display_re.search(buf) >= 0 ) + { + varItem->setDisplayId(display_re.cap(1).toInt()); + // Skip over the 'thing = ' part of expr to get the value + varItem->setText( VALUE_COLUMN, + display_re.cap(2).mid(varItem->text(VAR_NAME_COLUMN).length() + strlen(" = ")) ); + return; + } + } +} + +// After a program pause, this updates the new value of a Watch item +// expr is the thing = value part of "1: a = 1", id is the display number +void WatchRoot::updateWatchExpression(int id, const QString& expr) +{ + for ( QListViewItem *child = firstChild(); + child != 0; + child = child->nextSibling() ) + { + WatchVarItem *varItem = (WatchVarItem*) child; + if (varItem->displayId() == id) { + Q_ASSERT( expr.startsWith(varItem->text(VAR_NAME_COLUMN)) ); + // Skip over the 'thing = ' part of expr to get the value + varItem->setText( VALUE_COLUMN, + expr.mid(varItem->text(VAR_NAME_COLUMN).length() + strlen(" = ")) ); + return; + } + } +} + +void WatchRoot::savePartialProjectSession(QDomElement* el) +{ + QDomDocument domDoc = el->ownerDocument(); + if (domDoc.isNull()) { + return; + } + + QDomElement watchEl = domDoc.createElement("watchExpressions"); + + for ( QListViewItem *child = firstChild(); + child != 0; + child = child->nextSibling() ) + { + QDomElement subEl = domDoc.createElement("el"); + subEl.appendChild(domDoc.createTextNode(child->text(VAR_NAME_COLUMN))); + watchEl.appendChild(subEl); + } + + if (!watchEl.isNull()) { + el->appendChild(watchEl); + } + + return; +} + +void WatchRoot::restorePartialProjectSession(const QDomElement* el) +{ + QDomDocument domDoc = el->ownerDocument(); + if (domDoc.isNull()) { + return; + } + + QDomElement watchEl = el->namedItem("watchExpressions").toElement(); + QDomElement subEl = watchEl.firstChild().toElement(); + + while (!subEl.isNull()) { + new WatchVarItem(this, subEl.firstChild().toText().data(), UNKNOWN_TYPE); + + subEl = subEl.nextSibling().toElement(); + } + + return; +} + +// ************************************************************************** +// ************************************************************************** +// ************************************************************************** + +} + + +#include "variablewidget.moc" + diff --git a/languages/ruby/debugger/variablewidget.h b/languages/ruby/debugger/variablewidget.h new file mode 100644 index 00000000..c608ec45 --- /dev/null +++ b/languages/ruby/debugger/variablewidget.h @@ -0,0 +1,348 @@ +/*************************************************************************** + 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. * + * * + ***************************************************************************/ + +#ifndef _VARIABLEWIDGET_H_ +#define _VARIABLEWIDGET_H_ + +#include "rdbcontroller.h" + +#include <klistview.h> +#include <kcombobox.h> +#include <qwidget.h> +#include <qtooltip.h> +#include <kdebug.h> + +class KLineEdit; + +namespace RDBDebugger +{ + +class LazyFetchItem; +class VarFrameRoot; +class GlobalRoot; +class WatchRoot; +class VarItem; +class VariableTree; +class DbgController; +class Breakpoint; + +enum { + VAR_NAME_COLUMN = 0, + VALUE_COLUMN = 1 +}; + +enum DataType { + UNKNOWN_TYPE, + VALUE_TYPE, + REFERENCE_TYPE, + ARRAY_TYPE, + HASH_TYPE, + STRUCT_TYPE, + COLOR_TYPE, + STRING_TYPE +}; + +class VariableWidget : public QWidget +{ + Q_OBJECT + +public: + VariableWidget( QWidget *parent=0, const char *name=0 ); + + VariableTree *varTree() const + { return varTree_; } + + virtual void setEnabled(bool b); + + void restorePartialProjectSession(const QDomElement* el); + void savePartialProjectSession(QDomElement* el); + +protected: + virtual void focusInEvent(QFocusEvent *e); + +public slots: + void slotAddWatchExpression(); + void slotAddWatchExpression(const QString &expr); + +private: + VariableTree *varTree_; + KHistoryCombo *watchVarEditor_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class VariableTree : public KListView, public QToolTip +{ + Q_OBJECT +//we need this to be able to emit expandItem() from within LazyFetchItem +friend class LazyFetchItem; + +public: + VariableTree( VariableWidget *parent, const char *name=0 ); + virtual ~VariableTree(); + + // Clear everything but the Watch frame + void clear(); + + int activationId() const { return activationId_; } + void nextActivationId(); + + VarFrameRoot *findFrame(int frameNo, int threadNo) const; + + GlobalRoot *globalRoot(); + WatchRoot *watchRoot(); + + void resetWatchVars(); + void setCurrentThread(int currentThread) { currentThread_ = currentThread; } + + // Remove items that are not active + void prune(); + + // Look for a frame where 'needsVariables()' is true. + // If found, send commands to the debugger to fetch + // the variable values. + // Return true if a fetch has been scheduled, otherwise + // false. + bool schedule(); + + // Tell the controller whether or not to fetch the + // values of the global variables + void setFetchGlobals(bool fetch); + + // (from QToolTip) Display a tooltip when the cursor is over an item + virtual void maybeTip(const QPoint &); + + virtual void setSelected(QListViewItem * item, bool selected); + +signals: + void toggleWatchpoint(const QString &varName); + void selectFrame(int frame, int thread); + void expandItem(VarItem *item, const QCString &request); + void fetchGlobals(bool fetch); + void addWatchExpression(const QString& expr, bool execute); + void removeWatchExpression(int displayId); + +public slots: + void slotAddWatchExpression(const QString& watchVar); + void slotFrameActive(int frameNo, int threadNo, const QString& frameName); + void slotPressed(QListViewItem * item); + +private slots: + void slotContextMenu(KListView *, QListViewItem *item); + +private: + int activationId_; + int currentThread_; + VarFrameRoot * selectedFrame_; + + WatchRoot * watchRoot_; + GlobalRoot * globalRoot_; + + friend class VarFrameRoot; + friend class VarItem; + friend class WatchRoot; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class LazyFetchItem : public KListViewItem +{ +public: + LazyFetchItem(VariableTree *parent); + LazyFetchItem(LazyFetchItem *parent); + + virtual ~LazyFetchItem(); + + virtual int rtti() const { return RTTI_LAZY_FETCH_ITEM; } + + virtual void prune(); + virtual VarItem *findItem(const QString& name) const; + + int currentActivationId() const { return ((VariableTree*) listView())->activationId(); } + virtual void setActivationId() { activationId_ = currentActivationId(); } + bool isActive() const { return activationId_ == currentActivationId(); } + + void startWaitingForData() { waitingForData_ = true; } + void stopWaitingForData() { waitingForData_ = false; } + bool isWaitingForData() const { return waitingForData_; } + +protected: + void paintCell( QPainter *p, const QColorGroup &cg, + int column, int width, int align ); + +private: + int activationId_; + bool waitingForData_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class VarItem : public LazyFetchItem +{ +public: + VarItem( LazyFetchItem *parent, const QString &varName, DataType dataType ); + + virtual ~VarItem(); + + virtual int rtti() const { return RTTI_VAR_ITEM; } + virtual QString key(int column, bool ascending) const; + + QString fullName() const; + + DataType dataType() const; + void setDataType(DataType dataType); + + void setOpen(bool open); + void setText (int column, const QString& text); + + // Returns the text to be displayed as tooltip (the value) + QString tipText() const; + + // If the item is open, fetch details via a pp command + void update(); + + // The details from the pp command have arrived, parse them + // and update the UI + void expandValue(char *data); + +private: + void paintCell( QPainter *p, const QColorGroup &cg, + int column, int width, int align ); + +private: + QString key_; + QCString cache_; + DataType dataType_; + bool highlight_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class WatchVarItem : public VarItem +{ +public: + WatchVarItem( LazyFetchItem *parent, const QString &varName, DataType dataType, int displayId = -1); + + virtual ~WatchVarItem(); + + virtual int rtti() const { return RTTI_WATCH_VAR_ITEM; } + + // The id returned by rdb after a display expression is added + void setDisplayId(int id); + int displayId(); + +private: + int displayId_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class VarFrameRoot : public LazyFetchItem +{ +public: + VarFrameRoot(VariableTree *parent, int frame, int thread); + virtual ~VarFrameRoot(); + + virtual int rtti() const { return RTTI_VAR_FRAME_ROOT; } + + virtual QString key(int column, bool /*ascending*/) const { + return QString("%1%2").arg(RTTI_VAR_FRAME_ROOT).arg(text(column)); + } + + void addLocals(char *variables); + void setLocals(); + void setOpen(bool open); + + void setFrameName(const QString &frameName); + + virtual void setActivationId(); + bool needsVariables() const; + + int frameNo() { return frameNo_; } + int threadNo() { return threadNo_; } + +private: + bool needsVariables_; + int frameNo_; + int threadNo_; + QCString cache_; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class WatchRoot : public LazyFetchItem +{ +public: + WatchRoot(VariableTree * parent); + virtual ~WatchRoot(); + + virtual int rtti() const { return RTTI_WATCH_ROOT; } + + virtual QString key(int column, bool /*ascending*/) const { + return QString("%1%2").arg(RTTI_WATCH_ROOT).arg(text(column)); + } + + void setWatchExpression(char * buf, char * expr); + void updateWatchExpression(int id, const QString& expr); + + void restorePartialProjectSession(const QDomElement* el); + void savePartialProjectSession(QDomElement* el); +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class GlobalRoot : public LazyFetchItem +{ +public: + GlobalRoot(VariableTree * parent); + virtual ~GlobalRoot(); + + virtual int rtti() const { return RTTI_GLOBAL_ROOT; } + + virtual QString key(int column, bool /*ascending*/) const { + return QString("%1%2").arg(RTTI_GLOBAL_ROOT).arg(text(column)); + } + + void setOpen(bool open); + void setGlobals(char * globals); +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +} + +#endif |
