You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdevelop/languages/cpp/debugger/variablewidget.h

470 lines
14 KiB

/***************************************************************************
begin : Sun Aug 8 1999
copyright : (C) 1999 by John Birch
email : jbb@tdevelop.org
***************************************************************************/
/***************************************************************************
* *
* 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 "gdbcontroller.h"
#include "mi/gdbmi.h"
#include <klistview.h>
#include <kcombobox.h>
#include <tqwidget.h>
#include <tqtooltip.h>
#include <tqvaluevector.h>
#include <tqdatetime.h>
#include <tqguardedptr.h>
#include <tqmap.h>
#include <vector>
class KLineEdit;
class KPopupMenu;
namespace GDBDebugger
{
class TrimmableItem;
class VarFrameRoot;
class WatchRoot;
class VarItem;
class VariableTree;
class DbgController;
class GDBBreakpointWidget;
enum { VarNameCol = 0, ValueCol = 1, VarTypeCol = 2};
enum DataType { typeUnknown, typeValue, typePointer, typeReference,
typeStruct, typeArray, typeTQString, typeWhitespace,
typeName };
class VariableWidget : public TQWidget
{
Q_OBJECT
TQ_OBJECT
public:
VariableWidget( GDBController* controller,
GDBBreakpointWidget* breakpointWidget,
TQWidget *parent=0, const char *name=0 );
VariableTree *varTree() const
{ return varTree_; }
protected: // TQWidget overrides
void focusInEvent(TQFocusEvent *e);
public slots:
void slotAddWatchVariable();
void slotAddWatchVariable(const TQString &ident);
void slotEvaluateExpression();
void slotEvaluateExpression(const TQString &ident);
private:
VariableTree *varTree_;
// KLineEdit *watchVarEntry_;
friend class VariableTree;
KHistoryCombo *watchVarEditor_;
};
/***************************************************************************/
/***************************************************************************/
/***************************************************************************/
class VariableTree : public KListView, public TQToolTip
{
Q_OBJECT
TQ_OBJECT
public:
VariableTree(VariableWidget *parent,
GDBController* controller,
GDBBreakpointWidget* breakpointWidget,
const char *name=0 );
virtual ~VariableTree();
TQListViewItem *lastChild() const;
TQListViewItem *findRoot(TQListViewItem *item) const;
VarFrameRoot *findFrame(int frameNo, int threadNo) const;
WatchRoot *findWatch();
// (from TQToolTip) Display a tooltip when the cursor is over an item
virtual void maybeTip(const TQPoint &);
GDBController* controller() const { return controller_; }
signals:
void toggleWatchpoint(const TQString &varName);
public slots:
void slotAddWatchVariable(const TQString& watchVar);
void slotEvaluateExpression(const TQString& expression);
void slotEvent(GDBController::event_t);
void slotItemRenamed(TQListViewItem* item, int col, const TQString& text);
private slots:
void slotContextMenu(KListView *, TQListViewItem *item);
void slotVarobjNameChanged(const TQString& from, const TQString& to);
private: // Callbacks for gdb commands;
void argumentsReady(const GDBMI::ResultRecord&);
void localsReady(const GDBMI::ResultRecord&);
void frameIdReady(const TQValueVector<TQString>&);
void handleVarUpdate(const GDBMI::ResultRecord&);
void handleEvaluateExpression(const TQValueVector<TQString>&);
void variablesFetchDone();
void fetchSpecialValuesDone();
/** This is called when address of expression for which
popup is created is known.
If there's no address (for rvalue), does nothing
(leaving "Data breakpoint" item disabled).
Otherwise, enabled that item, and check is we
have data breakpoint for that address already.
*/
void handleAddressComputed(const GDBMI::ResultRecord& r);
private: // helper functions
/** Get (if exists) and create (otherwise) frame root for
the specified frameNo/threadNo combination.
*/
VarFrameRoot* demand_frame_root(int frameNo, int threadNo);
void updateCurrentFrame();
/** Copies the value (second column) of the specified item to
the clipboard.
*/
void copyToClipboard(TQListViewItem*);
private: // TQWidget overrides
void keyPressEvent(TQKeyEvent* e);
private:
GDBController* controller_;
GDBBreakpointWidget* breakpointWidget_;
int activeFlag_;
int iOutRadix;
bool justPaused_;
// Root of all recently printed expressions.
TrimmableItem* recentExpressions_;
VarFrameRoot* currentFrameItem;
TQTime fetch_time;
// Names of locals and arguments as reported by
// gdb.
std::vector<TQString> locals_and_arguments;
TQMap<TQString, VarItem*> varobj2varitem;
KPopupMenu* activePopup_;
static const int idToggleWatch = 10;
friend class VarFrameRoot;
friend class VarItem;
friend class WatchRoot;
};
/***************************************************************************/
/***************************************************************************/
/***************************************************************************/
/** List view item that can 'trim' outdated children.
The instances of this class hold a number of children corresponding
to variables. When program state changes, such as after a step in source,
some variable values can change, and some variables can go out of scope.
We need
- highlight modified variables
- remove gone variables
We could just remove all children and repopulate the list from
the data from debugger, but then we'd loose information about previous
variable values.
So, we first update the values, highlighting the modified variables, and
keeping track which variables were recieved from gdb. After that, the
'trim' method is called, removing all variables which were not recieved
from gdbr.
*/
class TrimmableItem : public KListViewItem
{
public:
TrimmableItem(VariableTree *parent);
TrimmableItem(TrimmableItem *parent);
virtual ~TrimmableItem();
TQListViewItem *lastChild() const;
protected:
void paintCell( TQPainter *p, const TQColorGroup &cg,
int column, int width, int align );
};
/***************************************************************************/
/***************************************************************************/
/***************************************************************************/
class VarItem : public TQObject,
public TrimmableItem
{
Q_OBJECT
TQ_OBJECT
public:
enum format_t { natural, hexadecimal, decimal, character, binary };
/** Creates top-level variable item from the specified expression.
Optionally, alternative display name can be provided.
*/
VarItem( TrimmableItem *parent,
const TQString& expression,
bool frozen = false);
VarItem( TrimmableItem *parent, const GDBMI::Value& varobj,
format_t format, bool baseClassMember);
virtual ~VarItem();
/// Returns the gdb expression for *this.
TQString gdbExpression() const;
/** Returns true is this VarItem should be unconditionally
updated on each step, not matter what's the result of
-var-update command.
*/
bool updateUnconditionally() const;
void updateValue();
void updateSpecialRepresentation(const TQString& s);
/** Creates a fresh gdbs "variable object", if needed.
Preconditions:
- frame id did not change
- this is a root variable
If the current type of expression, or it's address, it different
from it was previously, creates new "variable object" and
fetches new value.
Otherwise, does nothing.
*/
void recreateLocallyMaybe();
/** Tries to create new gdb variable object for this expression.
If successfull, updates all values. Otherwise, makes
itself disabled.
*/
void recreate();
void setOpen(bool open);
void setText (int column, const TQString& text);
/** Mark the variable as alive, or not alive.
Variables that are not alive a shown as "gray",
and nothing can be done about them except for
removing. */
void setAliveRecursively(bool enable);
/** Recursively clears the varobjName_ field, making
*this completely disconnected from gdb.
Automatically makes *this and children disables,
since there's no possible interaction with unhooked
object.
*/
void unhookFromGdb();
// Returns the text to be displayed as tooltip (the value)
TQString tipText() const;
format_t format() const;
void setFormat(format_t f);
format_t formatFromGdbModifier(char c) const;
/** Clears highliting for this variable and
all its children. */
void clearHighlight();
/** Sets new top-level textual value of this variable.
*/
void setValue(const TQString& new_value);
bool isAlive() const;
signals:
/** Emitted whenever the name of varobj associated with *this changes:
- when we've created initial varobj
- when we've changed varobj name as part of 'recreate' method
- when *this is destroyed and no longer uses any varobj.
Either 'from' or 'to' can be empty string.
*/
void varobjNameChange(const TQString& from, const TQString& to);
private:
/** Creates new gdb "variable object". The controller_,
expression_ and format_ member variables should already
be set.
*/
void createVarobj();
/** Precondition: 'name' is a name of existing
gdb variable object.
Effects:
- sets varobjName_ to 'name'
- sets format, if it's not default one
- gets initial value
- if item is open, gets children.
*/
void setVarobjName(const TQString& name);
/** Handle types that require special dispay, such as
TQString. Return true if this is such a type.
The 'originalValueType_' is already initialized
by the time this method is called.
*/
bool handleSpecialTypes();
void paintCell( TQPainter *p, const TQColorGroup &cg,
int column, int width, int align );
void varobjCreated(const GDBMI::ResultRecord& r);
void valueDone(const GDBMI::ResultRecord& r);
void childrenDone(const GDBMI::ResultRecord& r);
void childrenOfFakesDone(const GDBMI::ResultRecord& r);
void handleCurrentAddress(const TQValueVector<TQString>& lines);
void handleType(const TQValueVector<TQString>& lines);
void createChildren(const GDBMI::ResultRecord& r, bool children_of_fake);
/** Called to handle the output of the cli print command.
*/
void handleCliPrint(const TQValueVector<TQString>& lines);
// Assuming 'expression_' is already set, returns the
// displayName to use when showing this to the user.
// This function exists because if we have item with
// gdb expression '$1' and displayName 'P4', we want the child
// to show up as *P4, not as '*$1', so we can't uncondionally
// use expression gdb reports to us.
TQString displayName() const;
VariableTree* varTree() const;
TQString varobjFormatName() const;
private:
// The gdb expression for this varItem relatively to
// parent VarItem.
TQString expression_;
bool highlight_;
GDBController* controller_;
TQString varobjName_;
// the non-cast type of the variable
TQString originalValueType_;
bool oldSpecialRepresentationSet_;
TQString oldSpecialRepresentation_;
format_t format_;
static int varobjIndex;
int numChildren_;
bool childrenFetched_;
TQString currentAddress_;
TQString lastObtainedAddress_;
bool updateUnconditionally_;
bool frozen_;
/* Set to true whan calling createVarobj for the
first time, and to false other time. */
bool initialCreation_;
/* Set if this VarItem corresponds to base class suboject. */
bool baseClassMember_;
bool alive_;
};
/***************************************************************************/
/***************************************************************************/
/***************************************************************************/
class VarFrameRoot : public TrimmableItem
{
public:
VarFrameRoot(VariableTree *parent, int frameNo, int threadNo);
virtual ~VarFrameRoot();
void setOpen(bool open);
// Marks the frame as dirty, that is as having
// out of date values. As soon as we try to open
// this item, it will fetch new data.
void setDirty();
void setFrameName(const TQString &frameName)
{ setText(VarNameCol, frameName); setText(ValueCol, ""); }
bool needLocals() const { return needLocals_; }
bool matchDetails(int frameNo, int threadNo);
private:
bool needLocals_;
int frameNo_;
int threadNo_;
// Frame base and code address of the current inner-most
// frame. Needed so that if we can know when 'frame N' no longer
// is the same as 'frame N' when this 'VarFrameRoot' was created.
unsigned long long currentFrameBase;
unsigned long long currentFrameCodeAddress;
friend class VariableTree;
};
/***************************************************************************/
/***************************************************************************/
/***************************************************************************/
class WatchRoot : public TrimmableItem
{
public:
WatchRoot(VariableTree *parent);
virtual ~WatchRoot();
};
/***************************************************************************/
/***************************************************************************/
/***************************************************************************/
}
#endif