paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-08-18 05:39:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Debugger: refactor

Browse Source 
git-svn-id: trunk@44465 -
This commit is contained in:
martin 2014-03-18 14:58:46 +00:00
parent dd27f42211
commit 9246646d0f
7 changed files with 374 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
components/debuggerintf/dbgintfdebuggerbase.pp
View File

@ -612,8 +612,6 @@ type
property TypeInfo: TDBGType read GetTypeInfo write SetTypeInfo; property TypeInfo: TDBGType read GetTypeInfo write SetTypeInfo;
end; end;
{ TWatch }
{ TWatchBase } { TWatchBase }
TWatchBase = class(TDelayedUdateItem) TWatchBase = class(TDelayedUdateItem)
@ -640,16 +638,17 @@ type
property Values[const AThreadId: Integer; const AStackFrame: Integer]: TWatchValueBase property Values[const AThreadId: Integer; const AStackFrame: Integer]: TWatchValueBase
read GetValueBase; read GetValueBase;
end; end;
TBaseWatchClass = class of TWatchBase;
{ TWatches } { TWatches }
{ TWatchesBase } TWatches = class(TCollection)
TWatchesBase = class(TCollection)
protected protected
function GetItemBase(const AnIndex: Integer): TWatchBase; function GetItemBase(const AnIndex: Integer): TWatchBase;
procedure SetItemBase(const AnIndex: Integer; const AValue: TWatchBase); procedure SetItemBase(const AnIndex: Integer; const AValue: TWatchBase);
function WatchClass: TBaseWatchClass; virtual;
public public
constructor Create;
procedure ClearValues; virtual; abstract; procedure ClearValues; virtual; abstract;
function Find(const AExpression: String): TWatchBase; virtual; abstract; function Find(const AExpression: String): TWatchBase; virtual; abstract;
property Items[const AnIndex: Integer]: TWatchBase read GetItemBase write SetItemBase; default; property Items[const AnIndex: Integer]: TWatchBase read GetItemBase write SetItemBase; default;
@ -659,7 +658,7 @@ type
TWatchesSupplier = class(TDebuggerDataSupplier) TWatchesSupplier = class(TDebuggerDataSupplier)
private private
FCurrentWatches: TWatchesBase; FCurrentWatches: TWatches;
protected protected
procedure DoNewMonitor; override; procedure DoNewMonitor; override;
procedure DoStateChange(const AOldState: TDBGState); override; // workaround for state changes during TWatchValue.GetValue procedure DoStateChange(const AOldState: TDBGState); override; // workaround for state changes during TWatchValue.GetValue
@ -667,10 +666,20 @@ type
public public
constructor Create(const ADebugger: TDebuggerIntf); constructor Create(const ADebugger: TDebuggerIntf);
procedure RequestData(AWatchValue: TWatchValueBase); procedure RequestData(AWatchValue: TWatchValueBase);
property CurrentWatches: TWatchesBase read FCurrentWatches write FCurrentWatches; property CurrentWatches: TWatches read FCurrentWatches write FCurrentWatches;
end; end;
{ TWatchesMonitor }
TWatchesMonitor = class(TDebuggerDataMonitor) TWatchesMonitor = class(TDebuggerDataMonitor)
private
FWatches: TWatches;
protected
function CreateWatches: TWatches; virtual;
public
constructor Create;
destructor Destroy; override;
property Watches: TWatches read FWatches;
end; end;
{%endregion ^^^^^ Watches ^^^^^ } {%endregion ^^^^^ Watches ^^^^^ }
@ -742,7 +751,17 @@ type
property CurrentLocalsList: TLocalsList read FCurrentLocalsList write FCurrentLocalsList; property CurrentLocalsList: TLocalsList read FCurrentLocalsList write FCurrentLocalsList;
end; end;
{ TLocalsMonitor }
TLocalsMonitor = class(TDebuggerDataMonitor) TLocalsMonitor = class(TDebuggerDataMonitor)
private
FLocalsList: TLocalsList;
protected
function CreateLocalsList: TLocalsList; virtual;
public
constructor Create;
destructor Destroy; override;
property LocalsList: TLocalsList read FLocalsList;
end; end;
{%endregion ^^^^^ Locals ^^^^^ } {%endregion ^^^^^ Locals ^^^^^ }
@ -903,7 +922,17 @@ type
property CurrentRegistersList: TRegistersList read FCurrentRegistersList write FCurrentRegistersList; property CurrentRegistersList: TRegistersList read FCurrentRegistersList write FCurrentRegistersList;
end; end;
{ TRegistersMonitor }
TRegistersMonitor = class(TDebuggerDataMonitor) TRegistersMonitor = class(TDebuggerDataMonitor)
private
FRegistersList: TRegistersList;
protected
function CreateRegistersList: TRegistersList; virtual;
public
constructor Create;
destructor Destroy; override;
property RegistersList: TRegistersList read FRegistersList;
end; end;
{%endregion ^^^^^ Register ^^^^^ } {%endregion ^^^^^ Register ^^^^^ }
@ -1008,7 +1037,7 @@ type
{ TCallStackListBase } { TCallStackListBase }
TCallStackListBase = class TCallStackList = class
protected protected
function GetEntryBase(const AIndex: Integer): TCallStackBase; virtual; abstract; function GetEntryBase(const AIndex: Integer): TCallStackBase; virtual; abstract;
function GetEntryForThreadBase(const AThreadId: Integer): TCallStackBase; virtual; abstract; function GetEntryForThreadBase(const AThreadId: Integer): TCallStackBase; virtual; abstract;
@ -1023,7 +1052,7 @@ type
TCallStackSupplier = class(TDebuggerDataSupplier) TCallStackSupplier = class(TDebuggerDataSupplier)
private private
FCurrentCallStackList: TCallStackListBase; FCurrentCallStackList: TCallStackList;
protected protected
procedure DoNewMonitor; override; procedure DoNewMonitor; override;
//procedure CurrentChanged; //procedure CurrentChanged;
@ -1034,10 +1063,20 @@ type
procedure RequestCurrent(ACallstack: TCallStackBase); virtual; procedure RequestCurrent(ACallstack: TCallStackBase); virtual;
procedure RequestEntries(ACallstack: TCallStackBase); virtual; procedure RequestEntries(ACallstack: TCallStackBase); virtual;
procedure UpdateCurrentIndex; virtual; procedure UpdateCurrentIndex; virtual;
property CurrentCallStackList: TCallStackListBase read FCurrentCallStackList write FCurrentCallStackList; property CurrentCallStackList: TCallStackList read FCurrentCallStackList write FCurrentCallStackList;
end; end;
{ TCallStackMonitor }
TCallStackMonitor = class(TDebuggerDataMonitor) TCallStackMonitor = class(TDebuggerDataMonitor)
private
FCallStackList: TCallStackList;
protected
function CreateCallStackList: TCallStackList; virtual;
public
constructor Create;
destructor Destroy; override;
property CallStackList: TCallStackList read FCallStackList;
end; end;
{%endregion ^^^^^ Callstack ^^^^^ } {%endregion ^^^^^ Callstack ^^^^^ }
@ -1215,7 +1254,7 @@ type
{ TThreadsBase } { TThreadsBase }
TThreadsBase = class(TObject) TThreads = class(TObject)
protected protected
function GetEntryBase(const AnIndex: Integer): TCallStackEntryBase; virtual; abstract; function GetEntryBase(const AnIndex: Integer): TCallStackEntryBase; virtual; abstract;
function GetEntryByIdBase(const AnID: Integer): TCallStackEntryBase; virtual; abstract; function GetEntryByIdBase(const AnID: Integer): TCallStackEntryBase; virtual; abstract;
@ -1243,7 +1282,7 @@ type
TThreadsSupplier = class(TDebuggerDataSupplier) TThreadsSupplier = class(TDebuggerDataSupplier)
private private
FCurrentThreads: TThreadsBase; FCurrentThreads: TThreads;
protected protected
procedure DoNewMonitor; override; procedure DoNewMonitor; override;
procedure DoStateChange(const AOldState: TDBGState); override; procedure DoStateChange(const AOldState: TDBGState); override;
@ -1253,10 +1292,20 @@ type
procedure RequestMasterData; virtual; procedure RequestMasterData; virtual;
procedure ChangeCurrentThread({%H-}ANewId: Integer); virtual; procedure ChangeCurrentThread({%H-}ANewId: Integer); virtual;
procedure Changed; // TODO: needed because entries can not notify the monitor procedure Changed; // TODO: needed because entries can not notify the monitor
property CurrentThreads: TThreadsBase read FCurrentThreads write FCurrentThreads; property CurrentThreads: TThreads read FCurrentThreads write FCurrentThreads;
end; end;
{ TThreadsMonitor }
TThreadsMonitor = class(TDebuggerDataMonitor) TThreadsMonitor = class(TDebuggerDataMonitor)
private
FThreads: TThreads;
protected
function CreateThreads: TThreads; virtual;
public
constructor Create;
destructor Destroy; override;
property Threads: TThreads read FThreads;
end; end;
{%endregion ^^^^^ Threads ^^^^^ } {%endregion ^^^^^ Threads ^^^^^ }
@ -1799,6 +1848,45 @@ begin
end; end;
end; end;
{ TThreadsMonitor }
function TThreadsMonitor.CreateThreads: TThreads;
begin
Result := TThreads.Create;
end;
constructor TThreadsMonitor.Create;
begin
FThreads := CreateThreads;
inherited Create;
end;
destructor TThreadsMonitor.Destroy;
begin
inherited Destroy;
FreeAndNil(FThreads);
end;
{ TRegistersMonitor }
function TRegistersMonitor.CreateRegistersList: TRegistersList;
begin
Result := TRegistersList.Create;
end;
constructor TRegistersMonitor.Create;
begin
inherited Create;
FRegistersList := CreateRegistersList;
FRegistersList.AddReference;
end;
destructor TRegistersMonitor.Destroy;
begin
inherited Destroy;
ReleaseRefAndNil(FRegistersList);
end;
{ TDebuggerDataHandler } { TDebuggerDataHandler }
procedure TDebuggerDataHandler.DoStateEnterPause; procedure TDebuggerDataHandler.DoStateEnterPause;
@ -2279,16 +2367,26 @@ end;
{ TWatchesBase } { TWatchesBase }
function TWatchesBase.GetItemBase(const AnIndex: Integer): TWatchBase; function TWatches.GetItemBase(const AnIndex: Integer): TWatchBase;
begin begin
Result := TWatchBase(inherited Items[AnIndex]); Result := TWatchBase(inherited Items[AnIndex]);
end; end;
procedure TWatchesBase.SetItemBase(const AnIndex: Integer; const AValue: TWatchBase); procedure TWatches.SetItemBase(const AnIndex: Integer; const AValue: TWatchBase);
begin begin
inherited Items[AnIndex] := AValue; inherited Items[AnIndex] := AValue;
end; end;
function TWatches.WatchClass: TBaseWatchClass;
begin
Result := TWatchBase;
end;
constructor TWatches.Create;
begin
inherited Create(WatchClass);
end;
{ TCallStackBase } { TCallStackBase }
function TCallStackBase.GetHighestUnknown: Integer; function TCallStackBase.GetHighestUnknown: Integer;
@ -3084,6 +3182,25 @@ begin
FNotifiedState := dsNone; FNotifiedState := dsNone;
end; end;
{ TWatchesMonitor }
function TWatchesMonitor.CreateWatches: TWatches;
begin
Result := TWatches.Create;
end;
constructor TWatchesMonitor.Create;
begin
FWatches := CreateWatches;
inherited Create;
end;
destructor TWatchesMonitor.Destroy;
begin
inherited Destroy;
FreeAndNil(FWatches);
end;
{ TLocalsSupplier } { TLocalsSupplier }
procedure TLocalsSupplier.DoNewMonitor; procedure TLocalsSupplier.DoNewMonitor;
@ -3097,6 +3214,26 @@ begin
ALocals.SetDataValidity(ddsInvalid) ALocals.SetDataValidity(ddsInvalid)
end; end;
{ TLocalsMonitor }
function TLocalsMonitor.CreateLocalsList: TLocalsList;
begin
Result := TLocalsList.Create;
end;
constructor TLocalsMonitor.Create;
begin
FLocalsList := CreateLocalsList;
FLocalsList.AddReference;
inherited Create;
end;
destructor TLocalsMonitor.Destroy;
begin
inherited Destroy;
ReleaseRefAndNil(FLocalsList);
end;
{ TBaseLineInfo } { TBaseLineInfo }
function TBaseLineInfo.GetSource(const AnIndex: integer): String; function TBaseLineInfo.GetSource(const AnIndex: integer): String;
@ -3238,6 +3375,25 @@ begin
// //
end; end;
{ TCallStackMonitor }
function TCallStackMonitor.CreateCallStackList: TCallStackList;
begin
Result := TCallStackList.Create;
end;
constructor TCallStackMonitor.Create;
begin
FCallStackList := CreateCallStackList;
inherited Create;
end;
destructor TCallStackMonitor.Destroy;
begin
inherited Destroy;
FreeAndNil(FCallStackList);
end;
{ TThreadsSupplier } { TThreadsSupplier }
procedure TThreadsSupplier.Changed; procedure TThreadsSupplier.Changed;

12
components/lazdebuggergdbmi/gdbmidebugger.pp
View File

@ -1417,7 +1417,7 @@ type
TGDBMIDebuggerCommandThreads = class(TGDBMIDebuggerCommand) TGDBMIDebuggerCommandThreads = class(TGDBMIDebuggerCommand)
private private
FCurrentThreadId: Integer; FCurrentThreadId: Integer;
FCurrentThreads: TThreadsBase; FCurrentThreads: TThreads;
FSuccess: Boolean; FSuccess: Boolean;
FThreads: Array of TCallStackEntryBase; FThreads: Array of TCallStackEntryBase;
function GetThread(AnIndex: Integer): TCallStackEntryBase; function GetThread(AnIndex: Integer): TCallStackEntryBase;
@ -1431,7 +1431,7 @@ type
property Threads[AnIndex: Integer]: TCallStackEntryBase read GetThread; property Threads[AnIndex: Integer]: TCallStackEntryBase read GetThread;
property CurrentThreadId: Integer read FCurrentThreadId; property CurrentThreadId: Integer read FCurrentThreadId;
property Success: Boolean read FSuccess; property Success: Boolean read FSuccess;
property CurrentThreads: TThreadsBase read FCurrentThreads write FCurrentThreads; property CurrentThreads: TThreads read FCurrentThreads write FCurrentThreads;
end; end;
{ TGDBMIThreads } { TGDBMIThreads }
@ -1936,7 +1936,7 @@ function TGDBMIDebuggerInstruction.ProcessInputFromGdb(const AData: String): Boo
procedure DoExecAsync(Line: String); procedure DoExecAsync(Line: String);
var var
S: String; S: String;
ct: TThreadsBase; ct: TThreads;
i: Integer; i: Integer;
t: TCallStackEntryBase; t: TCallStackEntryBase;
begin begin
@ -1985,7 +1985,7 @@ function TGDBMIDebuggerInstruction.ProcessInputFromGdb(const AData: String): Boo
var var
S: String; S: String;
i, x: Integer; i, x: Integer;
ct: TThreadsBase; ct: TThreads;
t: TCallStackEntryBase; t: TCallStackEntryBase;
begin begin
S := GetPart('=', ',', Line, False, False); S := GetPart('=', ',', Line, False, False);
@ -2367,7 +2367,7 @@ var
var var
S: String; S: String;
i: Integer; i: Integer;
ct: TThreadsBase; ct: TThreads;
t: TCallStackEntryBase; t: TCallStackEntryBase;
begin begin
Result := False; Result := False;
@ -2418,7 +2418,7 @@ var
var var
S: String; S: String;
i, x: Integer; i, x: Integer;
ct: TThreadsBase; ct: TThreads;
t: TCallStackEntryBase; t: TCallStackEntryBase;
begin begin
S := GetPart('=', ',', Line, False, False); S := GetPart('=', ',', Line, False, False);

6
debugger/callstackdlg.pp
View File

@ -125,7 +125,7 @@ type
procedure DisableAllActions; procedure DisableAllActions;
procedure EnableAllActions; procedure EnableAllActions;
function GetSelectedSnapshot: TSnapshot; function GetSelectedSnapshot: TSnapshot;
function GetSelectedThreads(Snap: TSnapshot): TThreads; function GetSelectedThreads(Snap: TSnapshot): TIdeThreads;
function GetSelectedCallstack: TCallStack; function GetSelectedCallstack: TCallStack;
procedure DoBreakPointsChanged; override; procedure DoBreakPointsChanged; override;
procedure BreakPointChanged(const ASender: TIDEBreakPoints; const ABreakpoint: TIDEBreakPoint); procedure BreakPointChanged(const ASender: TIDEBreakPoints; const ABreakpoint: TIDEBreakPoint);
@ -428,7 +428,7 @@ begin
then Result := SnapshotManager.SelectedEntry; then Result := SnapshotManager.SelectedEntry;
end; end;
function TCallStackDlg.GetSelectedThreads(Snap: TSnapshot): TThreads; function TCallStackDlg.GetSelectedThreads(Snap: TSnapshot): TIdeThreads;
begin begin
if ThreadsMonitor = nil then exit(nil); if ThreadsMonitor = nil then exit(nil);
if Snap = nil if Snap = nil
@ -439,7 +439,7 @@ end;
function TCallStackDlg.GetSelectedCallstack: TCallStack; function TCallStackDlg.GetSelectedCallstack: TCallStack;
var var
Snap: TSnapshot; Snap: TSnapshot;
Threads: TThreads; Threads: TIdeThreads;
tid: LongInt; tid: LongInt;
begin begin
if (CallStackMonitor = nil) or (ThreadsMonitor = nil) if (CallStackMonitor = nil) or (ThreadsMonitor = nil)

300
debugger/debugger.pp
View File

@ -233,7 +233,7 @@ type
TIDEBreakPointGroup = class; TIDEBreakPointGroup = class;
TIDEBreakPointGroups = class; TIDEBreakPointGroups = class;
TWatch = class; TWatch = class;
TWatches = class; TIdeWatches = class;
TCurrentWatch = class; TCurrentWatch = class;
TCurrentWatches = class; TCurrentWatches = class;
TIdeWatchesMonitor = class; TIdeWatchesMonitor = class;
@ -541,7 +541,7 @@ const
type type
TWatchesEvent = TWatchesEvent =
procedure(const ASender: TWatches; const AWatch: TWatch) of object; procedure(const ASender: TIdeWatches; const AWatch: TWatch) of object;
TWatchesNotification = class(TDebuggerNotification) TWatchesNotification = class(TDebuggerNotification)
private private
@ -680,22 +680,20 @@ type
property Values[const AThreadId: Integer; const AStackFrame: Integer]: TWatchValue property Values[const AThreadId: Integer; const AStackFrame: Integer]: TWatchValue
read GetValue; read GetValue;
end; end;
TBaseWatchClass = class of TWatch;
{ TWatches } { TIdeWatches }
TWatches = class(TWatchesBase) TIdeWatches = class(TWatches)
private private
function GetItem(const AnIndex: Integer): TWatch; function GetItem(const AnIndex: Integer): TWatch;
procedure SetItem(const AnIndex: Integer; const AValue: TWatch); procedure SetItem(const AnIndex: Integer; const AValue: TWatch);
protected protected
function WatchClass: TBaseWatchClass; override;
procedure LoadDataFromXMLConfig(const AConfig: TXMLConfig; procedure LoadDataFromXMLConfig(const AConfig: TXMLConfig;
APath: string); APath: string);
procedure SaveDataToXMLConfig(const AConfig: TXMLConfig; procedure SaveDataToXMLConfig(const AConfig: TXMLConfig;
APath: string); APath: string);
public public
constructor Create;
constructor Create(const AWatchClass: TBaseWatchClass);
function Add(const AExpression: String): TWatch; function Add(const AExpression: String): TWatch;
function Find(const AExpression: String): TWatch; override; function Find(const AExpression: String): TWatch; override;
property Items[const AnIndex: Integer]: TWatch read GetItem write SetItem; default; property Items[const AnIndex: Integer]: TWatch read GetItem write SetItem; default;
@ -750,23 +748,24 @@ type
{ TCurrentWatches } { TCurrentWatches }
TCurrentWatches = class(TWatches) TCurrentWatches = class(TIdeWatches)
private private
FMonitor: TIdeWatchesMonitor; FMonitor: TIdeWatchesMonitor;
FSnapShot: TWatches; FSnapShot: TIdeWatches;
FDestroying: Boolean; FDestroying: Boolean;
procedure SetSnapShot(const AValue: TWatches); procedure SetSnapShot(const AValue: TIdeWatches);
procedure WatchesChanged(Sender: TObject); procedure WatchesChanged(Sender: TObject);
protected protected
function GetItem(const AnIndex: Integer): TCurrentWatch; function GetItem(const AnIndex: Integer): TCurrentWatch;
procedure SetItem(const AnIndex: Integer; const AValue: TCurrentWatch); procedure SetItem(const AnIndex: Integer; const AValue: TCurrentWatch);
protected protected
function WatchClass: TBaseWatchClass; override;
procedure NotifyAdd(const AWatch: TCurrentWatch); virtual; // called when a watch is added procedure NotifyAdd(const AWatch: TCurrentWatch); virtual; // called when a watch is added
procedure NotifyRemove(const AWatch: TCurrentWatch); virtual; // called by watch when destructed procedure NotifyRemove(const AWatch: TCurrentWatch); virtual; // called by watch when destructed
procedure DoModified; procedure DoModified;
procedure Update(Item: TCollectionItem); override; procedure Update(Item: TCollectionItem); override;
procedure RequestData(AWatchValue: TCurrentWatchValue); procedure RequestData(AWatchValue: TCurrentWatchValue);
property SnapShot: TWatches read FSnapShot write SetSnapShot; property SnapShot: TIdeWatches read FSnapShot write SetSnapShot;
public public
constructor Create(AMonitor: TIdeWatchesMonitor); constructor Create(AMonitor: TIdeWatchesMonitor);
destructor Destroy; override; destructor Destroy; override;
@ -789,8 +788,8 @@ type
FOnModified: TNotifyEvent; FOnModified: TNotifyEvent;
FIgnoreModified: Integer; FIgnoreModified: Integer;
FNotificationList: TWatchesNotificationList; FNotificationList: TWatchesNotificationList;
FCurrentWatches: TCurrentWatches; function GetCurrentWatches: TCurrentWatches;
function GetSnapshot(AnID: Pointer): TWatches; function GetSnapshot(AnID: Pointer): TIdeWatches;
function GetSupplier: TWatchesSupplier; function GetSupplier: TWatchesSupplier;
procedure SetSupplier(const AValue: TWatchesSupplier); procedure SetSupplier(const AValue: TWatchesSupplier);
protected protected
@ -804,6 +803,7 @@ type
procedure NotifyRemove(const AWatches: TCurrentWatches; const AWatch: TCurrentWatch); procedure NotifyRemove(const AWatches: TCurrentWatches; const AWatch: TCurrentWatch);
procedure NotifyUpdate(const AWatches: TCurrentWatches; const AWatch: TCurrentWatch); procedure NotifyUpdate(const AWatches: TCurrentWatches; const AWatch: TCurrentWatch);
procedure RequestData(AWatchValue: TCurrentWatchValue); procedure RequestData(AWatchValue: TCurrentWatchValue);
function CreateWatches: TWatches; override;
function CreateSnapshot(CreateEmpty: Boolean = False): TObject; function CreateSnapshot(CreateEmpty: Boolean = False): TObject;
public public
constructor Create; constructor Create;
@ -812,8 +812,8 @@ type
procedure RemoveNotification(const ANotification: TWatchesNotification); procedure RemoveNotification(const ANotification: TWatchesNotification);
procedure NewSnapshot(AnID: Pointer; CreateEmpty: Boolean = False); procedure NewSnapshot(AnID: Pointer; CreateEmpty: Boolean = False);
procedure RemoveSnapshot(AnID: Pointer); procedure RemoveSnapshot(AnID: Pointer);
property CurrentWatches: TCurrentWatches read FCurrentWatches; property CurrentWatches: TCurrentWatches read GetCurrentWatches;// FCurrentWatches;
property Snapshots[AnID: Pointer]: TWatches read GetSnapshot; property Snapshots[AnID: Pointer]: TIdeWatches read GetSnapshot;
property Supplier: TWatchesSupplier read GetSupplier write SetSupplier; property Supplier: TWatchesSupplier read GetSupplier write SetSupplier;
public public
procedure Clear; procedure Clear;
@ -913,8 +913,8 @@ type
TIdeLocalsMonitor = class(TLocalsMonitor) TIdeLocalsMonitor = class(TLocalsMonitor)
private private
FSnapshots: TDebuggerDataSnapShotList; FSnapshots: TDebuggerDataSnapShotList;
FCurrentLocalsList: TCurrentLocalsList;
FNotificationList: TDebuggerChangeNotificationList; FNotificationList: TDebuggerChangeNotificationList;
function GetCurrentLocalsList: TCurrentLocalsList;
function GetSnapshot(AnID: Pointer): TIDELocalsList; function GetSnapshot(AnID: Pointer): TIDELocalsList;
function GetSupplier: TLocalsSupplier; function GetSupplier: TLocalsSupplier;
procedure SetSupplier(const AValue: TLocalsSupplier); procedure SetSupplier(const AValue: TLocalsSupplier);
@ -926,6 +926,7 @@ type
procedure DoNewSupplier; override; procedure DoNewSupplier; override;
procedure RequestData(ALocals: TCurrentLocals); procedure RequestData(ALocals: TCurrentLocals);
function CreateSnapshot(CreateEmpty: Boolean = False): TObject; function CreateSnapshot(CreateEmpty: Boolean = False): TObject;
function CreateLocalsList: TLocalsList; override;
public public
constructor Create; constructor Create;
destructor Destroy; override; destructor Destroy; override;
@ -934,7 +935,7 @@ type
procedure RemoveNotification(const ANotification: TLocalsNotification); procedure RemoveNotification(const ANotification: TLocalsNotification);
procedure NewSnapshot(AnID: Pointer; CreateEmpty: Boolean = False); procedure NewSnapshot(AnID: Pointer; CreateEmpty: Boolean = False);
procedure RemoveSnapshot(AnID: Pointer); procedure RemoveSnapshot(AnID: Pointer);
property CurrentLocalsList: TCurrentLocalsList read FCurrentLocalsList; property CurrentLocalsList: TCurrentLocalsList read GetCurrentLocalsList;
property Snapshots[AnID: Pointer]: TIDELocalsList read GetSnapshot; property Snapshots[AnID: Pointer]: TIDELocalsList read GetSnapshot;
property Supplier: TLocalsSupplier read GetSupplier write SetSupplier; property Supplier: TLocalsSupplier read GetSupplier write SetSupplier;
end; end;
@ -1058,9 +1059,9 @@ type
TIdeRegistersMonitor = class(TRegistersMonitor) TIdeRegistersMonitor = class(TRegistersMonitor)
private private
FCurrentRegistersList: TCurrentIDERegistersList;
FNotificationList: TDebuggerChangeNotificationList; FNotificationList: TDebuggerChangeNotificationList;
FFlags: set of (rmNeedNotifyChange); FFlags: set of (rmNeedNotifyChange);
function GetCurrentRegistersList: TCurrentIDERegistersList;
function GetSupplier: TRegisterSupplier; function GetSupplier: TRegisterSupplier;
procedure SetSupplier(const AValue: TRegisterSupplier); procedure SetSupplier(const AValue: TRegisterSupplier);
protected protected
@ -1072,13 +1073,14 @@ type
procedure DoNewSupplier; override; procedure DoNewSupplier; override;
procedure RequestData(ARegisters: TCurrentIDERegisters); procedure RequestData(ARegisters: TCurrentIDERegisters);
//function CreateSnapshot(CreateEmpty: Boolean = False): TObject; override; //function CreateSnapshot(CreateEmpty: Boolean = False): TObject; override;
function CreateRegistersList: TRegistersList; override;
public public
constructor Create; constructor Create;
destructor Destroy; override; destructor Destroy; override;
procedure Clear; procedure Clear;
procedure AddNotification(const ANotification: TRegistersNotification); procedure AddNotification(const ANotification: TRegistersNotification);
procedure RemoveNotification(const ANotification: TRegistersNotification); procedure RemoveNotification(const ANotification: TRegistersNotification);
property CurrentRegistersList: TCurrentIDERegistersList read FCurrentRegistersList; property CurrentRegistersList: TCurrentIDERegistersList read GetCurrentRegistersList;
//property Snapshots[AnID: Pointer]: TIDERegistersList read GetSnapshot; //property Snapshots[AnID: Pointer]: TIDERegistersList read GetSnapshot;
property Supplier: TRegisterSupplier read GetSupplier write SetSupplier; property Supplier: TRegisterSupplier read GetSupplier write SetSupplier;
end; end;
@ -1233,7 +1235,7 @@ type
{ TCallStackList } { TCallStackList }
TCallStackList = class(TCallStackListBase) TIdeCallStackList = class(TCallStackList)
private private
FList: TList; FList: TList;
function GetEntry(const AIndex: Integer): TCallStack; function GetEntry(const AIndex: Integer): TCallStack;
@ -1253,7 +1255,7 @@ type
public public
constructor Create; constructor Create;
destructor Destroy; override; destructor Destroy; override;
procedure Assign(AnOther: TCallStackList); procedure Assign(AnOther: TIdeCallStackList);
procedure Clear; override; procedure Clear; override;
function Count: Integer; override; // Count of already requested CallStacks (via ThreadId) function Count: Integer; override; // Count of already requested CallStacks (via ThreadId)
property Entries[const AIndex: Integer]: TCallStack read GetEntry; default; property Entries[const AIndex: Integer]: TCallStack read GetEntry; default;
@ -1307,14 +1309,14 @@ type
{ TCurrentCallStackList } { TCurrentCallStackList }
TCurrentCallStackList = class(TCallStackList) TCurrentCallStackList = class(TIdeCallStackList)
private private
FMonitor: TIdeCallStackMonitor; FMonitor: TIdeCallStackMonitor;
FSnapShot: TCallStackList; FSnapShot: TIdeCallStackList;
procedure SetSnapShot(const AValue: TCallStackList); procedure SetSnapShot(const AValue: TIdeCallStackList);
protected protected
function GetEntryForThread(const AThreadId: Integer): TCallStack; override; function GetEntryForThread(const AThreadId: Integer): TCallStack; override;
property SnapShot: TCallStackList read FSnapShot write SetSnapShot; property SnapShot: TIdeCallStackList read FSnapShot write SetSnapShot;
public public
constructor Create(AMonitor: TIdeCallStackMonitor); constructor Create(AMonitor: TIdeCallStackMonitor);
end; end;
@ -1324,11 +1326,11 @@ type
TIdeCallStackMonitor = class(TCallStackMonitor) TIdeCallStackMonitor = class(TCallStackMonitor)
private private
FSnapshots: TDebuggerDataSnapShotList; FSnapshots: TDebuggerDataSnapShotList;
FCurrentCallStackList: TCurrentCallStackList;
FNotificationList: TDebuggerChangeNotificationList; FNotificationList: TDebuggerChangeNotificationList;
FUnitInfoProvider: TDebuggerUnitInfoProvider; FUnitInfoProvider: TDebuggerUnitInfoProvider;
procedure CallStackClear(Sender: TObject); procedure CallStackClear(Sender: TObject);
function GetSnapshot(AnID: Pointer): TCallStackList; function GetCurrentCallStackList: TCurrentCallStackList;
function GetSnapshot(AnID: Pointer): TIdeCallStackList;
function GetSupplier: TCallStackSupplier; function GetSupplier: TCallStackSupplier;
procedure SetSupplier(const AValue: TCallStackSupplier); procedure SetSupplier(const AValue: TCallStackSupplier);
protected protected
@ -1343,6 +1345,7 @@ type
procedure UpdateCurrentIndex; procedure UpdateCurrentIndex;
procedure DoNewSupplier; override; procedure DoNewSupplier; override;
function CreateSnapshot(CreateEmpty: Boolean = False): TObject; function CreateSnapshot(CreateEmpty: Boolean = False): TObject;
function CreateCallStackList: TCallStackList; override;
public public
constructor Create; constructor Create;
destructor Destroy; override; destructor Destroy; override;
@ -1352,8 +1355,8 @@ type
procedure RemoveSnapshot(AnID: Pointer); procedure RemoveSnapshot(AnID: Pointer);
procedure NotifyChange; // (sender) procedure NotifyChange; // (sender)
procedure NotifyCurrent; procedure NotifyCurrent;
property CurrentCallStackList: TCurrentCallStackList read FCurrentCallStackList; property CurrentCallStackList: TCurrentCallStackList read GetCurrentCallStackList;
property Snapshots[AnID: Pointer]: TCallStackList read GetSnapshot; property Snapshots[AnID: Pointer]: TIdeCallStackList read GetSnapshot;
property Supplier: TCallStackSupplier read GetSupplier write SetSupplier; property Supplier: TCallStackSupplier read GetSupplier write SetSupplier;
property UnitInfoProvider: TDebuggerUnitInfoProvider // Provided by DebugBoss, to map files to packages or project property UnitInfoProvider: TDebuggerUnitInfoProvider // Provided by DebugBoss, to map files to packages or project
read FUnitInfoProvider write FUnitInfoProvider; read FUnitInfoProvider write FUnitInfoProvider;
@ -1417,13 +1420,13 @@ type
property OnCurrent; property OnCurrent;
end; end;
TThreads = class; TIdeThreads = class;
{ TThreadEntry } { TThreadEntry }
TThreadEntry = class(TCallStackEntry) TThreadEntry = class(TCallStackEntry)
private private
FThreadOwner: TThreads; FThreadOwner: TIdeThreads;
FThreadId: Integer; FThreadId: Integer;
FThreadName: String; FThreadName: String;
FThreadState: String; FThreadState: String;
@ -1453,9 +1456,9 @@ type
constructor CreateCopy(const ASource: TThreadEntry); constructor CreateCopy(const ASource: TThreadEntry);
end; end;
{ TThreads } { TIdeThreads }
TThreads = class(TThreadsBase) TIdeThreads = class(TThreads)
private private
FCurrentThreadId: Integer; FCurrentThreadId: Integer;
FList: TList; FList: TList;
@ -1466,7 +1469,7 @@ type
function GetCurrentThreadId: Integer; override; function GetCurrentThreadId: Integer; override;
function GetEntryBase(const AnIndex: Integer): TCallStackEntryBase; override; function GetEntryBase(const AnIndex: Integer): TCallStackEntryBase; override;
function GetEntryByIdBase(const AnID: Integer): TCallStackEntryBase; override; function GetEntryByIdBase(const AnID: Integer): TCallStackEntryBase; override;
procedure Assign(AOther: TThreads); procedure Assign(AOther: TIdeThreads);
procedure LoadDataFromXMLConfig(const AConfig: TXMLConfig; procedure LoadDataFromXMLConfig(const AConfig: TXMLConfig;
APath: string; APath: string;
AUnitInvoPrv: TDebuggerUnitInfoProvider = nil AUnitInvoPrv: TDebuggerUnitInfoProvider = nil
@ -1496,16 +1499,16 @@ type
{ TCurrentThreads } { TCurrentThreads }
TCurrentThreads = class(TThreads) TCurrentThreads = class(TIdeThreads)
private private
FMonitor: TIdeThreadsMonitor; FMonitor: TIdeThreadsMonitor;
FDataValidity: TDebuggerDataState; FDataValidity: TDebuggerDataState;
FSnapShot: TThreads; FSnapShot: TIdeThreads;
procedure SetSnapShot(const AValue: TThreads); procedure SetSnapShot(const AValue: TIdeThreads);
protected protected
Paused: Boolean; // Todo: introduce Supplie.ReadyForRequest Paused: Boolean; // Todo: introduce Supplie.ReadyForRequest
procedure SetCurrentThreadId(AValue: Integer); override; procedure SetCurrentThreadId(AValue: Integer); override;
property SnapShot: TThreads read FSnapShot write SetSnapShot; property SnapShot: TIdeThreads read FSnapShot write SetSnapShot;
public public
constructor Create(AMonitor: TIdeThreadsMonitor); constructor Create(AMonitor: TIdeThreadsMonitor);
function Count: Integer; override; function Count: Integer; override;
@ -1526,9 +1529,9 @@ type
private private
FSnapshots: TDebuggerDataSnapShotList; FSnapshots: TDebuggerDataSnapShotList;
FUnitInfoProvider: TDebuggerUnitInfoProvider; FUnitInfoProvider: TDebuggerUnitInfoProvider;
FCurrentThreads: TCurrentThreads;
FNotificationList: TDebuggerChangeNotificationList; FNotificationList: TDebuggerChangeNotificationList;
function GetSnapshot(AnID: Pointer): TThreads; function GetCurrentThreads: TCurrentThreads;
function GetSnapshot(AnID: Pointer): TIdeThreads;
function GetSupplier: TThreadsSupplier; function GetSupplier: TThreadsSupplier;
procedure SetSupplier(const AValue: TThreadsSupplier); procedure SetSupplier(const AValue: TThreadsSupplier);
protected protected
@ -1540,6 +1543,7 @@ type
procedure Changed; procedure Changed;
procedure RequestData; procedure RequestData;
function CreateSnapshot(CreateEmpty: Boolean = False): TObject; function CreateSnapshot(CreateEmpty: Boolean = False): TObject;
function CreateThreads: TThreads; override;
public public
constructor Create; constructor Create;
destructor Destroy; override; destructor Destroy; override;
@ -1550,8 +1554,8 @@ type
procedure RemoveSnapshot(AnID: Pointer); procedure RemoveSnapshot(AnID: Pointer);
procedure ChangeCurrentThread(ANewId: Integer); procedure ChangeCurrentThread(ANewId: Integer);
procedure CurrentChanged; procedure CurrentChanged;
property CurrentThreads: TCurrentThreads read FCurrentThreads; property CurrentThreads: TCurrentThreads read GetCurrentThreads;
property Snapshots[AnID: Pointer]: TThreads read GetSnapshot; property Snapshots[AnID: Pointer]: TIdeThreads read GetSnapshot;
property Supplier: TThreadsSupplier read GetSupplier write SetSupplier; property Supplier: TThreadsSupplier read GetSupplier write SetSupplier;
property UnitInfoProvider: TDebuggerUnitInfoProvider // Provided by DebugBoss, to map files to packages or project property UnitInfoProvider: TDebuggerUnitInfoProvider // Provided by DebugBoss, to map files to packages or project
read FUnitInfoProvider write FUnitInfoProvider; read FUnitInfoProvider write FUnitInfoProvider;
@ -3182,6 +3186,11 @@ begin
Result := TIDELocalsList(FSnapshots.SnapShot[AnID]); Result := TIDELocalsList(FSnapshots.SnapShot[AnID]);
end; end;
function TIdeLocalsMonitor.GetCurrentLocalsList: TCurrentLocalsList;
begin
Result := TCurrentLocalsList(LocalsList);;
end;
procedure TIdeLocalsMonitor.SetSupplier(const AValue: TLocalsSupplier); procedure TIdeLocalsMonitor.SetSupplier(const AValue: TLocalsSupplier);
begin begin
inherited Supplier := AValue; inherited Supplier := AValue;
@ -3219,7 +3228,7 @@ begin
inherited DoNewSupplier; inherited DoNewSupplier;
NotifyChange(nil); NotifyChange(nil);
if Supplier <> nil then if Supplier <> nil then
Supplier.CurrentLocalsList := FCurrentLocalsList; Supplier.CurrentLocalsList := CurrentLocalsList;
end; end;
procedure TIdeLocalsMonitor.RequestData(ALocals: TCurrentLocals); procedure TIdeLocalsMonitor.RequestData(ALocals: TCurrentLocals);
@ -3236,13 +3245,16 @@ begin
then CurrentLocalsList.SnapShot := TIDELocalsList(Result); then CurrentLocalsList.SnapShot := TIDELocalsList(Result);
end; end;
function TIdeLocalsMonitor.CreateLocalsList: TLocalsList;
begin
Result := TCurrentLocalsList.Create(Self);
end;
constructor TIdeLocalsMonitor.Create; constructor TIdeLocalsMonitor.Create;
begin begin
FSnapshots := TDebuggerDataSnapShotList.Create; FSnapshots := TDebuggerDataSnapShotList.Create;
inherited; inherited;
FNotificationList := TDebuggerChangeNotificationList.Create; FNotificationList := TDebuggerChangeNotificationList.Create;
FCurrentLocalsList := TCurrentLocalsList.Create(Self);
FCurrentLocalsList.AddReference;
end; end;
destructor TIdeLocalsMonitor.Destroy; destructor TIdeLocalsMonitor.Destroy;
@ -3250,14 +3262,13 @@ begin
FSnapshots.Clear; FSnapshots.Clear;
FNotificationList.Clear; FNotificationList.Clear;
inherited Destroy; inherited Destroy;
ReleaseRefAndNil(FCurrentLocalsList);
FreeAndNil(FNotificationList); FreeAndNil(FNotificationList);
FreeAndNil(FSnapshots); FreeAndNil(FSnapshots);
end; end;
procedure TIdeLocalsMonitor.Clear; procedure TIdeLocalsMonitor.Clear;
begin begin
FCurrentLocalsList.Clear; CurrentLocalsList.Clear;
end; end;
procedure TIdeLocalsMonitor.AddNotification(const ANotification: TLocalsNotification); procedure TIdeLocalsMonitor.AddNotification(const ANotification: TLocalsNotification);
@ -3625,9 +3636,14 @@ begin
Result := TWatchesSupplier(inherited Supplier); Result := TWatchesSupplier(inherited Supplier);
end; end;
function TIdeWatchesMonitor.GetSnapshot(AnID: Pointer): TWatches; function TIdeWatchesMonitor.GetSnapshot(AnID: Pointer): TIdeWatches;
begin begin
Result := TWatches(FSnapshots.SnapShot[AnID]); Result := TIdeWatches(FSnapshots.SnapShot[AnID]);
end;
function TIdeWatchesMonitor.GetCurrentWatches: TCurrentWatches;
begin
Result := TCurrentWatches(Watches);
end; end;
procedure TIdeWatchesMonitor.SetSupplier(const AValue: TWatchesSupplier); procedure TIdeWatchesMonitor.SetSupplier(const AValue: TWatchesSupplier);
@ -3694,11 +3710,16 @@ begin
else AWatchValue.Validity := ddsInvalid; else AWatchValue.Validity := ddsInvalid;
end; end;
function TIdeWatchesMonitor.CreateWatches: TWatches;
begin
Result := TCurrentWatches.Create(Self);
end;
function TIdeWatchesMonitor.CreateSnapshot(CreateEmpty: Boolean = False): TObject; function TIdeWatchesMonitor.CreateSnapshot(CreateEmpty: Boolean = False): TObject;
begin begin
Result := TWatches.Create; Result := TIdeWatches.Create;
if not CreateEmpty if not CreateEmpty
then CurrentWatches.SnapShot := TWatches(Result); then CurrentWatches.SnapShot := TIdeWatches(Result);
end; end;
constructor TIdeWatchesMonitor.Create; constructor TIdeWatchesMonitor.Create;
@ -3706,7 +3727,6 @@ begin
FSnapshots := TDebuggerDataSnapShotList.Create; FSnapshots := TDebuggerDataSnapShotList.Create;
FIgnoreModified := 0; FIgnoreModified := 0;
FNotificationList := TWatchesNotificationList.Create; FNotificationList := TWatchesNotificationList.Create;
FCurrentWatches := TCurrentWatches.Create(Self);
inherited; inherited;
end; end;
@ -3715,7 +3735,6 @@ begin
FSnapshots.Clear; FSnapshots.Clear;
FNotificationList.Clear; FNotificationList.Clear;
inherited Destroy; inherited Destroy;
FreeAndNil(FCurrentWatches);
FreeAndNil(FNotificationList); FreeAndNil(FNotificationList);
FreeAndNil(FSnapshots); FreeAndNil(FSnapshots);
end; end;
@ -3745,17 +3764,17 @@ end;
procedure TIdeWatchesMonitor.Clear; procedure TIdeWatchesMonitor.Clear;
begin begin
FCurrentWatches.Clear; CurrentWatches.Clear;
end; end;
procedure TIdeWatchesMonitor.LoadFromXMLConfig(const AConfig: TXMLConfig; const APath: string); procedure TIdeWatchesMonitor.LoadFromXMLConfig(const AConfig: TXMLConfig; const APath: string);
begin begin
FCurrentWatches.LoadFromXMLConfig(AConfig, APath); CurrentWatches.LoadFromXMLConfig(AConfig, APath);
end; end;
procedure TIdeWatchesMonitor.SaveToXMLConfig(const AConfig: TXMLConfig; const APath: string); procedure TIdeWatchesMonitor.SaveToXMLConfig(const AConfig: TXMLConfig; const APath: string);
begin begin
FCurrentWatches.SaveToXMLConfig(AConfig, APath); CurrentWatches.SaveToXMLConfig(AConfig, APath);
end; end;
procedure TIdeWatchesMonitor.BeginIgnoreModified; procedure TIdeWatchesMonitor.BeginIgnoreModified;
@ -4124,7 +4143,7 @@ begin
inherited Create; inherited Create;
end; end;
procedure TCurrentCallStackList.SetSnapShot(const AValue: TCallStackList); procedure TCurrentCallStackList.SetSnapShot(const AValue: TIdeCallStackList);
var var
R: TCallStack; R: TCallStack;
i: Integer; i: Integer;
@ -4171,12 +4190,12 @@ end;
{ TCallStackList } { TCallStackList }
function TCallStackList.GetEntry(const AIndex: Integer): TCallStack; function TIdeCallStackList.GetEntry(const AIndex: Integer): TCallStack;
begin begin
Result := TCallStack(FList[AIndex]); Result := TCallStack(FList[AIndex]);
end; end;
function TCallStackList.GetEntryForThread(const AThreadId: Integer): TCallStack; function TIdeCallStackList.GetEntryForThread(const AThreadId: Integer): TCallStack;
var var
i: Integer; i: Integer;
begin begin
@ -4187,24 +4206,24 @@ begin
else Result := nil; else Result := nil;
end; end;
function TCallStackList.GetEntryBase(const AIndex: Integer): TCallStackBase; function TIdeCallStackList.GetEntryBase(const AIndex: Integer): TCallStackBase;
begin begin
Result := TCallStackBase(GetEntry(AIndex)); Result := TCallStackBase(GetEntry(AIndex));
end; end;
function TCallStackList.GetEntryForThreadBase(const AThreadId: Integer): TCallStackBase; function TIdeCallStackList.GetEntryForThreadBase(const AThreadId: Integer): TCallStackBase;
begin begin
Result := TCallStackBase(GetEntryForThread(AThreadId)); Result := TCallStackBase(GetEntryForThread(AThreadId));
end; end;
procedure TCallStackList.Add(ACallStack: TCallStack); procedure TIdeCallStackList.Add(ACallStack: TCallStack);
begin begin
assert(((Self is TCurrentCallStackList) and (ACallStack is TCurrentCallStack)) or ((not(Self is TCurrentCallStackList)) and not(ACallStack is TCurrentCallStack)), assert(((Self is TCurrentCallStackList) and (ACallStack is TCurrentCallStack)) or ((not(Self is TCurrentCallStackList)) and not(ACallStack is TCurrentCallStack)),
'TCallStackList.Add: entry and list differ (current and none current)'); 'TCallStackList.Add: entry and list differ (current and none current)');
FList.Add(ACallStack); FList.Add(ACallStack);
end; end;
procedure TCallStackList.LoadDataFromXMLConfig(const AConfig: TXMLConfig; procedure TIdeCallStackList.LoadDataFromXMLConfig(const AConfig: TXMLConfig;
APath: string; AUnitInvoPrv: TDebuggerUnitInfoProvider = nil); APath: string; AUnitInvoPrv: TDebuggerUnitInfoProvider = nil);
var var
c, i: Integer; c, i: Integer;
@ -4220,7 +4239,7 @@ begin
end; end;
end; end;
procedure TCallStackList.SaveDataToXMLConfig(const AConfig: TXMLConfig; APath: string; procedure TIdeCallStackList.SaveDataToXMLConfig(const AConfig: TXMLConfig; APath: string;
AUnitInvoPrv: TDebuggerUnitInfoProvider = nil); AUnitInvoPrv: TDebuggerUnitInfoProvider = nil);
var var
i: Integer; i: Integer;
@ -4231,7 +4250,7 @@ begin
Entries[i].SaveDataToXMLConfig(AConfig, APath + IntToStr(i) + '/', AUnitInvoPrv); Entries[i].SaveDataToXMLConfig(AConfig, APath + IntToStr(i) + '/', AUnitInvoPrv);
end; end;
procedure TCallStackList.Assign(AnOther: TCallStackList); procedure TIdeCallStackList.Assign(AnOther: TIdeCallStackList);
var var
i: Integer; i: Integer;
begin begin
@ -4240,19 +4259,19 @@ begin
FList.Add(TCallStack.CreateCopy(TCallStack(AnOther.FList[i]))); FList.Add(TCallStack.CreateCopy(TCallStack(AnOther.FList[i])));
end; end;
constructor TCallStackList.Create; constructor TIdeCallStackList.Create;
begin begin
FList := TList.Create; FList := TList.Create;
end; end;
destructor TCallStackList.Destroy; destructor TIdeCallStackList.Destroy;
begin begin
inherited Destroy; inherited Destroy;
Clear; Clear;
FreeAndNil(FList); FreeAndNil(FList);
end; end;
procedure TCallStackList.Clear; procedure TIdeCallStackList.Clear;
begin begin
while FList.Count > 0 do begin while FList.Count > 0 do begin
TObject(FList[0]).Free; TObject(FList[0]).Free;
@ -4260,7 +4279,7 @@ begin
end; end;
end; end;
function TCallStackList.Count: Integer; function TIdeCallStackList.Count: Integer;
begin begin
Result := FList.Count; Result := FList.Count;
end; end;
@ -4290,7 +4309,7 @@ begin
FMonitor.CurrentChanged; // TODO ChangedSelection FMonitor.CurrentChanged; // TODO ChangedSelection
end; end;
procedure TCurrentThreads.SetSnapShot(const AValue: TThreads); procedure TCurrentThreads.SetSnapShot(const AValue: TIdeThreads);
begin begin
assert((FSnapShot=nil) or (AValue=nil), 'Threads already have snapshot'); assert((FSnapShot=nil) or (AValue=nil), 'Threads already have snapshot');
if FSnapShot = AValue then exit; if FSnapShot = AValue then exit;
@ -4352,9 +4371,14 @@ begin
Result := TThreadsSupplier(inherited Supplier); Result := TThreadsSupplier(inherited Supplier);
end; end;
function TIdeThreadsMonitor.GetSnapshot(AnID: Pointer): TThreads; function TIdeThreadsMonitor.GetSnapshot(AnID: Pointer): TIdeThreads;
begin begin
Result := TThreads(FSnapshots.SnapShot[AnID]); Result := TIdeThreads(FSnapshots.SnapShot[AnID]);
end;
function TIdeThreadsMonitor.GetCurrentThreads: TCurrentThreads;
begin
Result :=TCurrentThreads(Threads);
end; end;
procedure TIdeThreadsMonitor.SetSupplier(const AValue: TThreadsSupplier); procedure TIdeThreadsMonitor.SetSupplier(const AValue: TThreadsSupplier);
@ -4395,7 +4419,7 @@ begin
if CurrentThreads <> nil then if CurrentThreads <> nil then
CurrentThreads.SetValidity(ddsUnknown); CurrentThreads.SetValidity(ddsUnknown);
if Supplier <> nil then if Supplier <> nil then
Supplier.CurrentThreads := FCurrentThreads; Supplier.CurrentThreads := CurrentThreads;
end; end;
procedure TIdeThreadsMonitor.RequestData; procedure TIdeThreadsMonitor.RequestData;
@ -4406,9 +4430,14 @@ end;
function TIdeThreadsMonitor.CreateSnapshot(CreateEmpty: Boolean = False): TObject; function TIdeThreadsMonitor.CreateSnapshot(CreateEmpty: Boolean = False): TObject;
begin begin
Result := TThreads.Create; Result := TIdeThreads.Create;
if not CreateEmpty if not CreateEmpty
then CurrentThreads.SnapShot := TThreads(Result); then CurrentThreads.SnapShot := TIdeThreads(Result);
end;
function TIdeThreadsMonitor.CreateThreads: TThreads;
begin
Result := TCurrentThreads.Create(self);
end; end;
procedure TIdeThreadsMonitor.Changed; procedure TIdeThreadsMonitor.Changed;
@ -4427,7 +4456,6 @@ begin
FSnapshots := TDebuggerDataSnapShotList.Create; FSnapshots := TDebuggerDataSnapShotList.Create;
inherited; inherited;
FNotificationList := TDebuggerChangeNotificationList.Create; FNotificationList := TDebuggerChangeNotificationList.Create;
FCurrentThreads := TCurrentThreads.Create(self);
end; end;
destructor TIdeThreadsMonitor.Destroy; destructor TIdeThreadsMonitor.Destroy;
@ -4436,14 +4464,13 @@ begin
FNotificationList.Clear; FNotificationList.Clear;
inherited Destroy; inherited Destroy;
FreeAndNil(FNotificationList); FreeAndNil(FNotificationList);
FreeAndNil(FCurrentThreads);
FreeAndNil(FSnapshots); FreeAndNil(FSnapshots);
end; end;
procedure TIdeThreadsMonitor.Clear; procedure TIdeThreadsMonitor.Clear;
begin begin
DebugLn(DBG_DATA_MONITORS, ['DebugDataMonitor: TIdeThreadsMonitor.Clear']); DebugLn(DBG_DATA_MONITORS, ['DebugDataMonitor: TIdeThreadsMonitor.Clear']);
FCurrentThreads.Clear; CurrentThreads.Clear;
Changed; Changed;
end; end;
@ -4629,15 +4656,15 @@ begin
FThreadState := ASource.FThreadState; FThreadState := ASource.FThreadState;
end; end;
{ TThreads } { TIdeThreads }
function TThreads.GetEntry(const AnIndex: Integer): TThreadEntry; function TIdeThreads.GetEntry(const AnIndex: Integer): TThreadEntry;
begin begin
if (AnIndex < 0) or (AnIndex >= Count) then exit(nil); if (AnIndex < 0) or (AnIndex >= Count) then exit(nil);
Result := TThreadEntry(FList[AnIndex]); Result := TThreadEntry(FList[AnIndex]);
end; end;
function TThreads.GetEntryById(const AnID: Integer): TThreadEntry; function TIdeThreads.GetEntryById(const AnID: Integer): TThreadEntry;
var var
i: Integer; i: Integer;
begin begin
@ -4651,28 +4678,28 @@ begin
Result := nil; Result := nil;
end; end;
procedure TThreads.SetCurrentThreadId(AValue: Integer); procedure TIdeThreads.SetCurrentThreadId(AValue: Integer);
begin begin
if FCurrentThreadId = AValue then exit; if FCurrentThreadId = AValue then exit;
FCurrentThreadId := AValue; FCurrentThreadId := AValue;
end; end;
function TThreads.GetCurrentThreadId: Integer; function TIdeThreads.GetCurrentThreadId: Integer;
begin begin
Result := FCurrentThreadId; Result := FCurrentThreadId;
end; end;
function TThreads.GetEntryBase(const AnIndex: Integer): TCallStackEntryBase; function TIdeThreads.GetEntryBase(const AnIndex: Integer): TCallStackEntryBase;
begin begin
Result := TCallStackEntryBase(GetEntry(AnIndex)); Result := TCallStackEntryBase(GetEntry(AnIndex));
end; end;
function TThreads.GetEntryByIdBase(const AnID: Integer): TCallStackEntryBase; function TIdeThreads.GetEntryByIdBase(const AnID: Integer): TCallStackEntryBase;
begin begin
Result := TCallStackEntryBase(GetEntryById(AnID)); Result := TCallStackEntryBase(GetEntryById(AnID));
end; end;
procedure TThreads.Assign(AOther: TThreads); procedure TIdeThreads.Assign(AOther: TIdeThreads);
var var
i: Integer; i: Integer;
begin begin
@ -4682,7 +4709,7 @@ begin
FList.Add(TThreadEntry.CreateCopy(TThreadEntry(AOther.FList[i]))); FList.Add(TThreadEntry.CreateCopy(TThreadEntry(AOther.FList[i])));
end; end;
procedure TThreads.LoadDataFromXMLConfig(const AConfig: TXMLConfig; APath: string; procedure TIdeThreads.LoadDataFromXMLConfig(const AConfig: TXMLConfig; APath: string;
AUnitInvoPrv: TDebuggerUnitInfoProvider = nil); AUnitInvoPrv: TDebuggerUnitInfoProvider = nil);
var var
c, i: Integer; c, i: Integer;
@ -4699,7 +4726,7 @@ begin
end; end;
end; end;
procedure TThreads.SaveDataToXMLConfig(const AConfig: TXMLConfig; APath: string; procedure TIdeThreads.SaveDataToXMLConfig(const AConfig: TXMLConfig; APath: string;
AUnitInvoPrv: TDebuggerUnitInfoProvider = nil); AUnitInvoPrv: TDebuggerUnitInfoProvider = nil);
var var
i: Integer; i: Integer;
@ -4711,24 +4738,24 @@ begin
Entries[i].SaveDataToXMLConfig(AConfig, APath + IntToStr(i) + '/', AUnitInvoPrv); Entries[i].SaveDataToXMLConfig(AConfig, APath + IntToStr(i) + '/', AUnitInvoPrv);
end; end;
constructor TThreads.Create; constructor TIdeThreads.Create;
begin begin
FList := TList.Create; FList := TList.Create;
end; end;
destructor TThreads.Destroy; destructor TIdeThreads.Destroy;
begin begin
Clear; Clear;
FreeAndNil(FList); FreeAndNil(FList);
inherited Destroy; inherited Destroy;
end; end;
function TThreads.Count: Integer; function TIdeThreads.Count: Integer;
begin begin
Result := FList.Count; Result := FList.Count;
end; end;
procedure TThreads.Clear; procedure TIdeThreads.Clear;
begin begin
while FList.Count > 0 do begin while FList.Count > 0 do begin
TThreadEntry(Flist[0]).Free; TThreadEntry(Flist[0]).Free;
@ -4736,14 +4763,14 @@ begin
end; end;
end; end;
procedure TThreads.Add(AThread: TCallStackEntryBase); procedure TIdeThreads.Add(AThread: TCallStackEntryBase);
begin begin
FList.Add(TThreadEntry.CreateCopy(AThread as TThreadEntry)); FList.Add(TThreadEntry.CreateCopy(AThread as TThreadEntry));
if FList.Count = 1 then if FList.Count = 1 then
FCurrentThreadId := (AThread as TThreadEntry).ThreadId; FCurrentThreadId := (AThread as TThreadEntry).ThreadId;
end; end;
procedure TThreads.Remove(AThread: TCallStackEntryBase); procedure TIdeThreads.Remove(AThread: TCallStackEntryBase);
begin begin
FList.Remove(AThread); FList.Remove(AThread);
if FCurrentThreadId = (AThread as TThreadEntry).ThreadId then begin if FCurrentThreadId = (AThread as TThreadEntry).ThreadId then begin
@ -4755,7 +4782,7 @@ begin
AThread.Free; AThread.Free;
end; end;
function TThreads.CreateEntry(const AIndex: Integer; const AnAdress: TDbgPtr; function TIdeThreads.CreateEntry(const AIndex: Integer; const AnAdress: TDbgPtr;
const AnArguments: TStrings; const AFunctionName: String; const FileName, FullName: String; const AnArguments: TStrings; const AFunctionName: String; const FileName, FullName: String;
const ALine: Integer; const AThreadId: Integer; const AThreadName: String; const ALine: Integer; const AThreadId: Integer; const AThreadName: String;
const AThreadState: String; AState: TDebuggerDataState): TCallStackEntryBase; const AThreadState: String; AState: TDebuggerDataState): TCallStackEntryBase;
@ -4765,9 +4792,9 @@ begin
TThreadEntry(Result).FThreadOwner := self; TThreadEntry(Result).FThreadOwner := self;
end; end;
procedure TThreads.SetValidity(AValidity: TDebuggerDataState); procedure TIdeThreads.SetValidity(AValidity: TDebuggerDataState);
begin begin
assert(false, 'TThreads.SetValidity'); assert(false, 'TIdeThreads.SetValidity');
end; end;
(******************************************************************************) (******************************************************************************)
@ -5979,10 +6006,10 @@ begin
end; end;
{ =========================================================================== } { =========================================================================== }
{ TWatches } { TIdeWatches }
{ =========================================================================== } { =========================================================================== }
function TWatches.Add(const AExpression: String): TWatch; function TIdeWatches.Add(const AExpression: String): TWatch;
begin begin
BeginUpdate; BeginUpdate;
Result := TWatch(inherited Add); Result := TWatch(inherited Add);
@ -5990,17 +6017,22 @@ begin
EndUpdate; EndUpdate;
end; end;
function TWatches.GetItem(const AnIndex: Integer): TWatch; function TIdeWatches.GetItem(const AnIndex: Integer): TWatch;
begin begin
Result := TWatch(inherited Items[AnIndex]); Result := TWatch(inherited Items[AnIndex]);
end; end;
procedure TWatches.SetItem(const AnIndex: Integer; const AValue: TWatch); procedure TIdeWatches.SetItem(const AnIndex: Integer; const AValue: TWatch);
begin begin
inherited Items[AnIndex] := AValue; inherited Items[AnIndex] := AValue;
end; end;
procedure TWatches.LoadDataFromXMLConfig(const AConfig: TXMLConfig; APath: string); function TIdeWatches.WatchClass: TBaseWatchClass;
begin
Result := TWatch;
end;
procedure TIdeWatches.LoadDataFromXMLConfig(const AConfig: TXMLConfig; APath: string);
var var
c, i: Integer; c, i: Integer;
begin begin
@ -6011,7 +6043,7 @@ begin
Add('').LoadDataFromXMLConfig(AConfig, APath + IntToStr(i) + '/'); Add('').LoadDataFromXMLConfig(AConfig, APath + IntToStr(i) + '/');
end; end;
procedure TWatches.SaveDataToXMLConfig(const AConfig: TXMLConfig; APath: string); procedure TIdeWatches.SaveDataToXMLConfig(const AConfig: TXMLConfig; APath: string);
var var
i: Integer; i: Integer;
begin begin
@ -6021,17 +6053,7 @@ begin
Items[i].SaveDataToXMLConfig(AConfig, APath + IntToStr(i) + '/'); Items[i].SaveDataToXMLConfig(AConfig, APath + IntToStr(i) + '/');
end; end;
constructor TWatches.Create; function TIdeWatches.Find(const AExpression: String): TWatch;
begin
Create(TWatch);
end;
constructor TWatches.Create(const AWatchClass: TBaseWatchClass);
begin
inherited Create(AWatchClass);
end;
function TWatches.Find(const AExpression: String): TWatch;
var var
n: Integer; n: Integer;
S: String; S: String;
@ -6046,7 +6068,7 @@ begin
Result := nil; Result := nil;
end; end;
procedure TWatches.ClearValues; procedure TIdeWatches.ClearValues;
var var
n: Integer; n: Integer;
begin begin
@ -6076,7 +6098,7 @@ constructor TCurrentWatches.Create(AMonitor: TIdeWatchesMonitor);
begin begin
FDestroying := False; FDestroying := False;
FMonitor := AMonitor; FMonitor := AMonitor;
inherited Create(TCurrentWatch); inherited Create;
end; end;
destructor TCurrentWatches.Destroy; destructor TCurrentWatches.Destroy;
@ -6095,7 +6117,7 @@ begin
Changed; Changed;
end; end;
procedure TCurrentWatches.SetSnapShot(const AValue: TWatches); procedure TCurrentWatches.SetSnapShot(const AValue: TIdeWatches);
var var
R: TWatch; R: TWatch;
i: Integer; i: Integer;
@ -6184,6 +6206,11 @@ begin
inherited SetItem(AnIndex, AValue); inherited SetItem(AnIndex, AValue);
end; end;
function TCurrentWatches.WatchClass: TBaseWatchClass;
begin
Result := TCurrentWatch;
end;
procedure TCurrentWatches.Update(Item: TCollectionItem); procedure TCurrentWatches.Update(Item: TCollectionItem);
var var
m, c: Integer; m, c: Integer;
@ -6413,6 +6440,11 @@ begin
Result := TRegisterSupplier(inherited Supplier); Result := TRegisterSupplier(inherited Supplier);
end; end;
function TIdeRegistersMonitor.GetCurrentRegistersList: TCurrentIDERegistersList;
begin
Result := TCurrentIDERegistersList(RegistersList);
end;
procedure TIdeRegistersMonitor.SetSupplier(const AValue: TRegisterSupplier); procedure TIdeRegistersMonitor.SetSupplier(const AValue: TRegisterSupplier);
begin begin
inherited Supplier := AValue; inherited Supplier := AValue;
@ -6454,7 +6486,7 @@ begin
inherited DoNewSupplier; inherited DoNewSupplier;
NotifyChange(nil); NotifyChange(nil);
if Supplier <> nil then if Supplier <> nil then
Supplier.CurrentRegistersList := FCurrentRegistersList; Supplier.CurrentRegistersList := CurrentRegistersList;
end; end;
procedure TIdeRegistersMonitor.RequestData(ARegisters: TCurrentIDERegisters); procedure TIdeRegistersMonitor.RequestData(ARegisters: TCurrentIDERegisters);
@ -6464,25 +6496,27 @@ begin
else ARegisters.DataValidity := ddsInvalid; else ARegisters.DataValidity := ddsInvalid;
end; end;
function TIdeRegistersMonitor.CreateRegistersList: TRegistersList;
begin
Result := TCurrentIDERegistersList.Create(Self);
end;
constructor TIdeRegistersMonitor.Create; constructor TIdeRegistersMonitor.Create;
begin begin
inherited Create; inherited Create;
FNotificationList := TDebuggerChangeNotificationList.Create; FNotificationList := TDebuggerChangeNotificationList.Create;
FCurrentRegistersList := TCurrentIDERegistersList.Create(Self);
FCurrentRegistersList.AddReference;
end; end;
destructor TIdeRegistersMonitor.Destroy; destructor TIdeRegistersMonitor.Destroy;
begin begin
FNotificationList.Clear; FNotificationList.Clear;
inherited Destroy; inherited Destroy;
ReleaseRefAndNil(FCurrentRegistersList);
FreeAndNil(FNotificationList); FreeAndNil(FNotificationList);
end; end;
procedure TIdeRegistersMonitor.Clear; procedure TIdeRegistersMonitor.Clear;
begin begin
FCurrentRegistersList.Clear; CurrentRegistersList.Clear;
end; end;
procedure TIdeRegistersMonitor.AddNotification(const ANotification: TRegistersNotification); procedure TIdeRegistersMonitor.AddNotification(const ANotification: TRegistersNotification);
@ -6994,7 +7028,6 @@ constructor TIdeCallStackMonitor.Create;
begin begin
FSnapshots := TDebuggerDataSnapShotList.Create; FSnapshots := TDebuggerDataSnapShotList.Create;
FNotificationList := TDebuggerChangeNotificationList.Create; FNotificationList := TDebuggerChangeNotificationList.Create;
FCurrentCallStackList := TCurrentCallStackList.Create(Self);
inherited Create; inherited Create;
end; end;
@ -7004,7 +7037,6 @@ begin
FNotificationList.Clear; FNotificationList.Clear;
inherited; inherited;
FreeAndNil(FNotificationList); FreeAndNil(FNotificationList);
FreeAndNil(FCurrentCallStackList);
FreeAndNil(FSnapshots); FreeAndNil(FSnapshots);
end; end;
@ -7079,7 +7111,7 @@ begin
inherited DoNewSupplier; inherited DoNewSupplier;
NotifyChange; NotifyChange;
if Supplier <> nil then if Supplier <> nil then
Supplier.CurrentCallStackList := FCurrentCallStackList; Supplier.CurrentCallStackList := CurrentCallStackList;
end; end;
procedure TIdeCallStackMonitor.CallStackClear(Sender: TObject); procedure TIdeCallStackMonitor.CallStackClear(Sender: TObject);
@ -7090,9 +7122,14 @@ begin
NotifyChange; NotifyChange;
end; end;
function TIdeCallStackMonitor.GetSnapshot(AnID: Pointer): TCallStackList; function TIdeCallStackMonitor.GetCurrentCallStackList: TCurrentCallStackList;
begin begin
Result := TCallStackList(FSnapshots.SnapShot[AnID]); Result := TCurrentCallStackList(CallStackList);
end;
function TIdeCallStackMonitor.GetSnapshot(AnID: Pointer): TIdeCallStackList;
begin
Result := TIdeCallStackList(FSnapshots.SnapShot[AnID]);
end; end;
function TIdeCallStackMonitor.GetSupplier: TCallStackSupplier; function TIdeCallStackMonitor.GetSupplier: TCallStackSupplier;
@ -7112,9 +7149,14 @@ end;
function TIdeCallStackMonitor.CreateSnapshot(CreateEmpty: Boolean = False): TObject; function TIdeCallStackMonitor.CreateSnapshot(CreateEmpty: Boolean = False): TObject;
begin begin
Result := TCallStackList.Create; Result := TIdeCallStackList.Create;
if not CreateEmpty if not CreateEmpty
then CurrentCallStackList.SnapShot := TCallStackList(Result); then CurrentCallStackList.SnapShot := TIdeCallStackList(Result);
end;
function TIdeCallStackMonitor.CreateCallStackList: TCallStackList;
begin
Result := TCurrentCallStackList.Create(Self);
end; end;
procedure TIdeCallStackMonitor.RemoveNotification(const ANotification: TCallStackNotification); procedure TIdeCallStackMonitor.RemoveNotification(const ANotification: TCallStackNotification);

8
debugger/localsdlg.pp
View File

@ -69,7 +69,7 @@ type
FUpdateFlags: set of (ufNeedUpdating); FUpdateFlags: set of (ufNeedUpdating);
procedure LocalsChanged(Sender: TObject); procedure LocalsChanged(Sender: TObject);
function GetThreadId: Integer; function GetThreadId: Integer;
function GetSelectedThreads(Snap: TSnapshot): TThreads; function GetSelectedThreads(Snap: TSnapshot): TIdeThreads;
function GetStackframe: Integer; function GetStackframe: Integer;
function GetSelectedSnapshot: TSnapshot; function GetSelectedSnapshot: TSnapshot;
protected protected
@ -276,7 +276,7 @@ end;
function TLocalsDlg.GetThreadId: Integer; function TLocalsDlg.GetThreadId: Integer;
var var
Threads: TThreads; Threads: TIdeThreads;
begin begin
Result := -1; Result := -1;
if (ThreadsMonitor = nil) then exit; if (ThreadsMonitor = nil) then exit;
@ -286,7 +286,7 @@ begin
else Result := 1; else Result := 1;
end; end;
function TLocalsDlg.GetSelectedThreads(Snap: TSnapshot): TThreads; function TLocalsDlg.GetSelectedThreads(Snap: TSnapshot): TIdeThreads;
begin begin
if ThreadsMonitor = nil then exit(nil); if ThreadsMonitor = nil then exit(nil);
if Snap = nil if Snap = nil
@ -297,7 +297,7 @@ end;
function TLocalsDlg.GetStackframe: Integer; function TLocalsDlg.GetStackframe: Integer;
var var
Snap: TSnapshot; Snap: TSnapshot;
Threads: TThreads; Threads: TIdeThreads;
tid: LongInt; tid: LongInt;
Stack: TCallStack; Stack: TCallStack;
begin begin

8
debugger/threaddlg.pp
View File

@ -25,7 +25,7 @@ type
FUpdateFlags: set of (ufThreadChanged); FUpdateFlags: set of (ufThreadChanged);
procedure JumpToSource; procedure JumpToSource;
function GetSelectedSnapshot: TSnapshot; function GetSelectedSnapshot: TSnapshot;
function GetSelectedThreads(Snap: TSnapshot): TThreads; function GetSelectedThreads(Snap: TSnapshot): TIdeThreads;
protected protected
procedure DoEndUpdate; override; procedure DoEndUpdate; override;
procedure ThreadsChanged(Sender: TObject); procedure ThreadsChanged(Sender: TObject);
@ -76,7 +76,7 @@ var
i: Integer; i: Integer;
s: String; s: String;
Item: TListItem; Item: TListItem;
Threads: TThreads; Threads: TIdeThreads;
Snap: TSnapshot; Snap: TSnapshot;
begin begin
if IsUpdating then begin if IsUpdating then begin
@ -179,7 +179,7 @@ procedure TThreadsDlg.tbCurrentClick(Sender: TObject);
var var
Item: TListItem; Item: TListItem;
id: LongInt; id: LongInt;
Threads: TThreads; Threads: TIdeThreads;
begin begin
Item := lvThreads.Selected; Item := lvThreads.Selected;
if Item = nil then exit; if Item = nil then exit;
@ -220,7 +220,7 @@ begin
then Result := SnapshotManager.SelectedEntry; then Result := SnapshotManager.SelectedEntry;
end; end;
function TThreadsDlg.GetSelectedThreads(Snap: TSnapshot): TThreads; function TThreadsDlg.GetSelectedThreads(Snap: TSnapshot): TIdeThreads;
begin begin
if Snap = nil if Snap = nil
then Result := ThreadsMonitor.CurrentThreads then Result := ThreadsMonitor.CurrentThreads

30
debugger/watchesdlg.pp
View File

@ -130,28 +130,28 @@ type
procedure popEnableAllClick(Sender: TObject); procedure popEnableAllClick(Sender: TObject);
procedure popDeleteAllClick(Sender: TObject); procedure popDeleteAllClick(Sender: TObject);
private private
function GetWatches: TWatches; function GetWatches: TIdeWatches;
procedure ContextChanged(Sender: TObject); procedure ContextChanged(Sender: TObject);
procedure SnapshotChanged(Sender: TObject); procedure SnapshotChanged(Sender: TObject);
private private
FWatchesInView: TWatches; FWatchesInView: TIdeWatches;
FPowerImgIdx, FPowerImgIdxGrey: Integer; FPowerImgIdx, FPowerImgIdxGrey: Integer;
FUpdateAllNeeded, FUpdatingAll: Boolean; FUpdateAllNeeded, FUpdatingAll: Boolean;
FStateFlags: TWatchesDlgStateFlags; FStateFlags: TWatchesDlgStateFlags;
function GetSelected: TCurrentWatch; function GetSelected: TCurrentWatch;
function GetThreadId: Integer; function GetThreadId: Integer;
function GetSelectedThreads(Snap: TSnapshot): TThreads; function GetSelectedThreads(Snap: TSnapshot): TIdeThreads;
function GetStackframe: Integer; function GetStackframe: Integer;
procedure WatchAdd(const ASender: TWatches; const AWatch: TWatch); procedure WatchAdd(const ASender: TIdeWatches; const AWatch: TWatch);
procedure WatchUpdate(const ASender: TWatches; const AWatch: TWatch); procedure WatchUpdate(const ASender: TIdeWatches; const AWatch: TWatch);
procedure WatchRemove(const ASender: TWatches; const AWatch: TWatch); procedure WatchRemove(const ASender: TIdeWatches; const AWatch: TWatch);
procedure UpdateInspectPane; procedure UpdateInspectPane;
procedure UpdateItem(const AItem: TListItem; const AWatch: TWatch); procedure UpdateItem(const AItem: TListItem; const AWatch: TWatch);
procedure UpdateAll; procedure UpdateAll;
procedure DisableAllActions; procedure DisableAllActions;
function GetSelectedSnapshot: TSnapshot; function GetSelectedSnapshot: TSnapshot;
property Watches: TWatches read GetWatches; property Watches: TIdeWatches read GetWatches;
protected protected
procedure DoEndUpdate; override; procedure DoEndUpdate; override;
procedure DoWatchesChanged; override; procedure DoWatchesChanged; override;
@ -283,7 +283,7 @@ end;
function TWatchesDlg.GetThreadId: Integer; function TWatchesDlg.GetThreadId: Integer;
var var
Threads: TThreads; Threads: TIdeThreads;
begin begin
Result := -1; Result := -1;
if (ThreadsMonitor = nil) then exit; if (ThreadsMonitor = nil) then exit;
@ -293,7 +293,7 @@ begin
else Result := 1; else Result := 1;
end; end;
function TWatchesDlg.GetSelectedThreads(Snap: TSnapshot): TThreads; function TWatchesDlg.GetSelectedThreads(Snap: TSnapshot): TIdeThreads;
begin begin
if ThreadsMonitor = nil then exit(nil); if ThreadsMonitor = nil then exit(nil);
if Snap = nil if Snap = nil
@ -304,7 +304,7 @@ end;
function TWatchesDlg.GetStackframe: Integer; function TWatchesDlg.GetStackframe: Integer;
var var
Snap: TSnapshot; Snap: TSnapshot;
Threads: TThreads; Threads: TIdeThreads;
tid: LongInt; tid: LongInt;
Stack: TCallStack; Stack: TCallStack;
begin begin
@ -574,7 +574,7 @@ end;
procedure TWatchesDlg.SnapshotChanged(Sender: TObject); procedure TWatchesDlg.SnapshotChanged(Sender: TObject);
var var
NewWatches: TWatches; NewWatches: TIdeWatches;
begin begin
DebugLn(DBG_DATA_MONITORS, ['DebugDataWindow: TWatchesDlg.SnapshotChanged ', DbgSName(Sender), ' Upd:', IsUpdating]); DebugLn(DBG_DATA_MONITORS, ['DebugDataWindow: TWatchesDlg.SnapshotChanged ', DbgSName(Sender), ' Upd:', IsUpdating]);
lvWatches.BeginUpdate; lvWatches.BeginUpdate;
@ -592,7 +592,7 @@ begin
end; end;
end; end;
function TWatchesDlg.GetWatches: TWatches; function TWatchesDlg.GetWatches: TIdeWatches;
var var
Snap: TSnapshot; Snap: TSnapshot;
begin begin
@ -911,7 +911,7 @@ begin
then Result := SnapshotManager.SelectedEntry; then Result := SnapshotManager.SelectedEntry;
end; end;
procedure TWatchesDlg.WatchAdd(const ASender: TWatches; const AWatch: TWatch); procedure TWatchesDlg.WatchAdd(const ASender: TIdeWatches; const AWatch: TWatch);
var var
Item: TListItem; Item: TListItem;
begin begin
@ -928,7 +928,7 @@ begin
lvWatchesSelectItem(nil, nil, False); lvWatchesSelectItem(nil, nil, False);
end; end;
procedure TWatchesDlg.WatchUpdate(const ASender: TWatches; const AWatch: TWatch); procedure TWatchesDlg.WatchUpdate(const ASender: TIdeWatches; const AWatch: TWatch);
var var
Item: TListItem; Item: TListItem;
begin begin
@ -948,7 +948,7 @@ begin
finally DebugLnExit(DBG_DATA_MONITORS, ['DebugDataWindow: TWatchesDlg.WatchUpdate']); end; finally DebugLnExit(DBG_DATA_MONITORS, ['DebugDataWindow: TWatchesDlg.WatchUpdate']); end;
end; end;
procedure TWatchesDlg.WatchRemove(const ASender: TWatches; const AWatch: TWatch); procedure TWatchesDlg.WatchRemove(const ASender: TIdeWatches; const AWatch: TWatch);
begin begin
lvWatches.Items.FindData(AWatch).Free; lvWatches.Items.FindData(AWatch).Free;
lvWatchesSelectItem(nil, nil, False); lvWatchesSelectItem(nil, nil, False);