paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-04-07 12:18:03 +02:00
Code Issues Packages Projects Releases Wiki Activity

LazBuild: Remove IdeDebugger dependency. Split debugger related parts of TProject to new unit ProjectDebugLink.

Browse Source
This commit is contained in:
Juha 2023-07-24 11:57:40 +03:00
parent 8e7b4f0289
commit 64391dbd96
10 changed files with 431 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
components/buildintf/projectintf.pas
View File

@ -533,7 +533,6 @@ type
procedure SetSessionStorage(const AValue: TProjectSessionStorage); virtual;
procedure SetTitle(const AValue: String); virtual;
procedure SetUseManifest(AValue: boolean); virtual; abstract;
function GetCurrentDebuggerBackend: String; virtual; abstract;
public
constructor Create({%H-}ProjectDescription: TProjectDescriptor); virtual; reintroduce;
destructor Destroy; override;
@ -593,7 +592,6 @@ type
property Resources: TObject read FResources; // TAbstractProjectResources
property UseManifest: boolean read GetUseManifest write SetUseManifest;
property RunParameters: TAbstractRunParamsOptions read FRunParameters;
property CurrentDebuggerBackend: String read GetCurrentDebuggerBackend;
end;
TLazProjectClass = class of TLazProject;

18
debugger/frames/debugger_class_options.pas
View File

@ -42,7 +42,7 @@ uses
// IdeConfig
EnvironmentOpts, TransferMacros,
// IDE
LazarusIDEStrConsts, PathEditorDlg, DialogProcs, Project, EnvGuiOptions;
LazarusIDEStrConsts, PathEditorDlg, DialogProcs, DebugManager, EnvGuiOptions;
type
@ -127,8 +127,7 @@ implementation
{ TDebuggerClassOptionsFrame }
procedure TDebuggerClassOptionsFrame.cmbDebuggerPathEditingDone(Sender: TObject
);
procedure TDebuggerClassOptionsFrame.cmbDebuggerPathEditingDone(Sender: TObject);
var
ParsedFName: String;
begin
@ -161,8 +160,7 @@ begin
LblWarnClassChange.Visible := True;
end;
procedure TDebuggerClassOptionsFrame.cmdOpenAdditionalPathClick(
Sender: TObject);
procedure TDebuggerClassOptionsFrame.cmdOpenAdditionalPathClick(Sender: TObject);
begin
PathEditorDialog.Path:=txtAdditionalPath.Text;
PathEditorDialog.Templates:=GetForcedPathDelims(
@ -350,8 +348,7 @@ begin
UpdateDebuggerClassDropDown;
end;
procedure TDebuggerClassOptionsFrame.cmbDebuggerTypeEditingDone(
Sender: TObject);
procedure TDebuggerClassOptionsFrame.cmbDebuggerTypeEditingDone(Sender: TObject);
begin
UpdateDebuggerClass;
FetchDebuggerSpecificOptions;
@ -595,9 +592,10 @@ begin
if ShowWarningOverridenByProject and Assigned(FSelectedDbgPropertiesConfig) then
lblWarningProject.Visible := not (
(Project1.DebuggerBackend = FSelectedDbgPropertiesConfig.UID) or
(Project1.DebuggerBackend = 'IDE') or
( (Project1.DebuggerBackend = '') and (Project1.DebuggerPropertiesConfigList.Count = 0) )
(DebugBossMgr.ProjectLink.DebuggerBackend = FSelectedDbgPropertiesConfig.UID) or
(DebugBossMgr.ProjectLink.DebuggerBackend = 'IDE') or
( (DebugBossMgr.ProjectLink.DebuggerBackend = '') and
(DebugBossMgr.ProjectLink.DebuggerPropertiesConfigList.Count = 0) )
);
end;

35
ide/debugmanager.pas
View File

@ -66,7 +66,7 @@ uses
// IdeConfig
LazConf,
// IDE
CompilerOptions, SourceEditor, ProjectDefs, Project,
CompilerOptions, SourceEditor, ProjectDefs, Project, ProjectDebugLink,
LazarusIDEStrConsts, MainBar, MainIntf, MainBase, BaseBuildManager, SourceMarks,
DebugEventsForm, EnvGuiOptions;
@ -139,6 +139,7 @@ type
private
FDebugger: TDebuggerIntf;
FEventLogManager: TDebugEventLogManager;
FProjectLink: TProjectDebugLink;
FUnitInfoProvider: TDebuggerUnitInfoProvider;
FDialogs: array[TDebugDialogType] of TDebuggerDlg;
FInStateChange: Boolean;
@ -169,7 +170,6 @@ type
ASrcEdit: TSourceEditor);
procedure GetSourceEditorForBreakPoint(const ABreakpoint: TIDEBreakPoint;
var ASrcEdit: TSourceEditor);
// Dialog routines
procedure DestroyDebugDialog(const ADialogType: TDebugDialogType);
procedure InitDebugOutputDlg;
@ -308,6 +308,8 @@ type
procedure UnregisterStateChangeHandler(AHandler: TDebuggerStateChangeNotification); override;
procedure RegisterWatchesInvalidatedHandler(AHandler: TNotifyEvent); override;
procedure UnregisterWatchesInvalidatedHandler(AHandler: TNotifyEvent); override;
property ProjectLink: TProjectDebugLink read FProjectLink;
end;
function GetDebugManager: TDebugManager;
@ -2079,6 +2081,7 @@ begin
RegisterValueFormatter(skFloat, 'TDateTime', @DBGDateTimeFormatter);
FEventLogManager := TDebugEventLogManager.Create;
FProjectLink := TProjectDebugLink.Create;
end;
destructor TDebugManager.Destroy;
@ -2096,6 +2099,7 @@ begin
SetDebugger(nil);
FreeAndNil(FCurrentWatches);
FreeAndNil(FProjectLink);
FreeAndNil(FEventLogManager);
FreeAndNil(FSnapshots);
FreeAndNil(FWatches);
@ -2460,13 +2464,13 @@ begin
try
ValueConverterSelectorList.Clear;
if (Project1 <> nil) and (Project1.UseBackendConverterFromProject) then
Project1.BackendConverterConfig.AssignEnabledTo(ValueConverterSelectorList, True);
if (Project1 = nil) or (Project1.UseBackendConverterFromIDE) then
if {(Project1 <> nil) and} (FProjectLink.UseBackendConverterFromProject) then
FProjectLink.BackendConverterConfig.AssignEnabledTo(ValueConverterSelectorList, True);
if (Project1 = nil) or (FProjectLink.UseBackendConverterFromIDE) then
DebuggerOptions.BackendConverterConfig.AssignEnabledTo(ValueConverterSelectorList, True);
if (Project1 <> nil) then
ProjectValueConverterSelectorList := Project1.BackendConverterConfig;
ProjectValueConverterSelectorList := FProjectLink.BackendConverterConfig;
finally
ValueConverterSelectorList.Unlock;
end;
@ -2583,15 +2587,16 @@ begin
// check if debugger needs an Exe and the exe is there
if (NewDebuggerClass.NeedsExePath)
and not FileIsExecutable(Project1.GetParsedDebuggerFilename)
and not FileIsExecutable(FProjectLink.GetParsedDebuggerFilename)
then begin
if not PromptOnError then
ClearPathAndExe
else begin
debugln(['Info: (lazarus) [TDebugManager.GetLaunchPathAndExe] Project1.DebuggerFilename="',Project1.DebuggerFilename,'"']);
debugln(['Info: (lazarus) [TDebugManager.GetLaunchPathAndExe] Project1.DebuggerFilename="',
FProjectLink.DebuggerFilename,'"']);
IDEMessageDialog(lisDebuggerInvalid,
Format(lisTheDebuggerDoesNotExistsOrIsNotExecutableSeeEnviro,
[Project1.DebuggerFilename, LineEnding, LineEnding+LineEnding]),
[FProjectLink.DebuggerFilename, LineEnding, LineEnding+LineEnding]),
mtError,[mbOK]);
Exit;
end;
@ -2641,7 +2646,7 @@ begin
// check if debugger is already created with the right type
if (FDebugger <> nil)
and (not (FDebugger.ClassType = NewDebuggerClass) // exact class match
or (FDebugger.ExternalDebugger <> Project1.GetParsedDebuggerFilename)
or (FDebugger.ExternalDebugger <> FProjectLink.GetParsedDebuggerFilename)
or (FDebugger.State in [dsError])
)
then begin
@ -2652,7 +2657,7 @@ begin
// create debugger object
if FDebugger = nil
then SetDebugger(NewDebuggerClass.Create(Project1.GetParsedDebuggerFilename));
then SetDebugger(NewDebuggerClass.Create(FProjectLink.GetParsedDebuggerFilename));
if FDebugger = nil
then begin
@ -2660,7 +2665,7 @@ begin
Exit;
end;
DbgCfg := Project1.CurrentDebuggerPropertiesConfig;
DbgCfg := FProjectLink.CurrentDebuggerPropertiesConfig;
if (DbgCfg <> nil) and (DbgCfg.DebuggerProperties <> nil) then
FDebugger.GetProperties.Assign(DbgCfg.DebuggerProperties);
@ -2761,10 +2766,10 @@ function TDebugManager.DoSetBreakkPointWarnIfNoDebugger: boolean;
var
DbgClass: TDebuggerClass;
begin
DbgClass := Project1.CurrentDebuggerClass;
DbgClass := FProjectLink.CurrentDebuggerClass;
if (DbgClass=nil)
or (DbgClass.NeedsExePath
and (not FileIsExecutableCached(Project1.GetParsedDebuggerFilename)))
and (not FileIsExecutableCached(FProjectLink.GetParsedDebuggerFilename)))
then begin
if IDEQuestionDialog(lisDbgMangNoDebuggerSpecified,
Format(lisDbgMangThereIsNoDebuggerSpecifiedSettingBreakpointsHaveNo,[LineEnding]),
@ -3356,7 +3361,7 @@ end;
function TDebugManager.GetDebuggerClass: TDebuggerClass;
begin
Result := Project1.CurrentDebuggerClass;
Result := FProjectLink.CurrentDebuggerClass;
if Result = nil then
Result := TProcessDebugger;
end;

21
ide/frames/project_debug_options.pas
View File

@ -5,16 +5,22 @@ unit project_debug_options;
interface
uses
SysUtils,
SysUtils, Classes,
// LazUtils
LazTracer,
// LCL
Forms, Controls, Graphics, Dialogs, StdCtrls, ExtCtrls,
// LazControls
DividerBevel,
// IdeIntf
IDEOptionsIntf, IDEOptEditorIntf, ProjectIntf, DividerBevel,
IDEOptionsIntf, IDEOptEditorIntf, ProjectIntf,
// IdeConfig
EnvironmentOpts,
// IdeDebugger
IdeDebuggerOpts,
// IDE
Project, LazarusIDEStrConsts, EnvironmentOpts, debugger_class_options,
IdeDebuggerOpts, Classes;
Project, DebugManager, ProjectDebugLink,
LazarusIDEStrConsts, debugger_class_options;
type
@ -192,9 +198,8 @@ end;
procedure TProjectDebugOptionsFrame.ReadSettings(AOptions: TAbstractIDEOptions);
begin
if not (AOptions is TProjectIDEOptions) then exit;
fProject:=(AOptions as TProjectIDEOptions).Project;
with fProject do
with fProject.DebuggerLink as TProjectDebugLink do
begin
Self.FDebuggerBackend := DebuggerBackend;
chkStoreInSession.Checked := StoreDebuggerClassConfInSession;
@ -206,11 +211,9 @@ end;
procedure TProjectDebugOptionsFrame.WriteSettings(AOptions: TAbstractIDEOptions);
begin
if not (AOptions is TProjectIDEOptions) then exit;
UpdateDebuggerBackend;
with (AOptions as TProjectIDEOptions).Project do
with (AOptions as TProjectIDEOptions).Project.DebuggerLink as TProjectDebugLink do
begin
DebuggerBackend := FDebuggerBackend;
StoreDebuggerClassConfInSession := chkStoreInSession.Checked;

42
ide/frames/project_valconv_options.pas
View File

@ -5,10 +5,22 @@ unit Project_ValConv_Options;
interface
uses
SysUtils, Forms, Controls, ExtCtrls, StdCtrls, IDEOptEditorIntf,
IDEOptionsIntf, DividerBevel, DbgIntfDebuggerBase, IdeDebuggerStringConstants,
IdeDbgValueConverterSettingsFrame, IdeDebuggerOpts,
IdeDebuggerBackendValueConv, Project, Classes, LazarusIDEStrConsts;
SysUtils, Classes,
// LCL
Forms, ExtCtrls, StdCtrls,
// LazControls
DividerBevel,
// BuildIntf
IDEOptionsIntf,
// IdeIntf
IDEOptEditorIntf,
// DebuggerIntf
DbgIntfDebuggerBase,
// IdeDebugger
IdeDebuggerStringConstants, IdeDbgValueConverterSettingsFrame, IdeDebuggerOpts,
IdeDebuggerBackendValueConv,
// IDE
Project, DebugManager, LazarusIDEStrConsts;
type
@ -64,13 +76,13 @@ procedure TIdeProjectValConvOptionsFrame.ReadSettings(
begin
if FValConvList = nil then
FValConvList := TIdeDbgValueConvertSelectorList.Create;
FValConvList.Assign(Project1.BackendConverterConfig);
FValConvList.Assign(DebugBossMgr.ProjectLink.BackendConverterConfig);
FValConvList.Changed := False;
DbgValConvFrame1.ValConvList := FValConvList;
chkStoreInSession.Checked := Project1.StoreBackendConverterConfigInSession;
chkUseGlobalList.Checked := Project1.UseBackendConverterFromIDE;
chkUseProjList.Checked := Project1.UseBackendConverterFromProject;
chkStoreInSession.Checked := DebugBossMgr.ProjectLink.StoreBackendConverterConfigInSession;
chkUseGlobalList.Checked := DebugBossMgr.ProjectLink.UseBackendConverterFromIDE;
chkUseProjList.Checked := DebugBossMgr.ProjectLink.UseBackendConverterFromProject;
end;
procedure TIdeProjectValConvOptionsFrame.WriteSettings(
@ -81,17 +93,17 @@ begin
DbgValConvFrame1.SaveCurrent;
HasChg :=
(Project1.UseBackendConverterFromIDE <> chkUseGlobalList.Checked) or
(Project1.UseBackendConverterFromProject <> chkUseProjList.Checked) or
(DebugBossMgr.ProjectLink.UseBackendConverterFromIDE <> chkUseGlobalList.Checked) or
(DebugBossMgr.ProjectLink.UseBackendConverterFromProject <> chkUseProjList.Checked) or
FValConvList.Changed;
Project1.StoreBackendConverterConfigInSession := chkStoreInSession.Checked;
Project1.UseBackendConverterFromIDE := chkUseGlobalList.Checked;
Project1.UseBackendConverterFromProject := chkUseProjList.Checked;
DebugBossMgr.ProjectLink.StoreBackendConverterConfigInSession := chkStoreInSession.Checked;
DebugBossMgr.ProjectLink.UseBackendConverterFromIDE := chkUseGlobalList.Checked;
DebugBossMgr.ProjectLink.UseBackendConverterFromProject := chkUseProjList.Checked;
if FValConvList.Changed then begin
Project1.BackendConverterConfig.Assign(FValConvList);
Project1.BackendConverterConfig.Changed := True;
DebugBossMgr.ProjectLink.BackendConverterConfig.Assign(FValConvList);
DebugBossMgr.ProjectLink.BackendConverterConfig.Changed := True;
end;
if (DebugBossManager <> nil) and HasChg then

5
ide/lazarus.lpi
View File

@ -1473,6 +1473,11 @@
<IsPartOfProject Value="True"/>
<UnitName Value="EnvGuiOptions"/>
</Unit>
<Unit>
<Filename Value="projectdebuglink.pas"/>
<IsPartOfProject Value="True"/>
<UnitName Value="ProjectDebugLink"/>
</Unit>
</Units>
</ProjectOptions>
<CompilerOptions>

19
ide/lazbuild.lpi
View File

@ -13,9 +13,15 @@
<SessionStorage Value="InIDEConfig"/>
<UseAppBundle Value="False"/>
</General>
<MacroValues Count="1">
<Macro1 Name="LCLWidgetType" Value="nogui"/>
</MacroValues>
<BuildModes Count="2">
<Item1 Name="Debug" Default="True"/>
<Item2 Name="Release">
<MacroValues Count="1">
<Macro1 Name="LCLWidgetType" Value="nogui"/>
</MacroValues>
<CompilerOptions>
<Version Value="11"/>
<Target>
@ -41,7 +47,7 @@
</CompilerOptions>
</Item2>
<SharedMatrixOptions Count="1">
<Item1 ID="037437114172" Type="IDEMacro" MacroName="LCLWidgetType" Value="nogui"/>
<Item1 ID="037437114172" Modes="Debug,Release" Type="IDEMacro" MacroName="LCLWidgetType" Value="nogui"/>
</SharedMatrixOptions>
</BuildModes>
<PublishOptions>
@ -52,10 +58,10 @@
</RunParams>
<RequiredPackages Count="4">
<Item1>
<PackageName Value="IdeConfig"/>
<PackageName Value="IDEIntf"/>
</Item1>
<Item2>
<PackageName Value="IdeDebugger"/>
<PackageName Value="IdeConfig"/>
</Item2>
<Item3>
<PackageName Value="DebuggerIntf"/>
@ -64,7 +70,7 @@
<PackageName Value="CodeTools"/>
</Item4>
</RequiredPackages>
<Units Count="4">
<Units Count="3">
<Unit0>
<Filename Value="lazbuild.lpr"/>
<IsPartOfProject Value="True"/>
@ -79,11 +85,6 @@
<IsPartOfProject Value="True"/>
<UnitName Value="BaseBuildManager"/>
</Unit2>
<Unit3>
<Filename Value="idecmdline.pas"/>
<IsPartOfProject Value="True"/>
<UnitName Value="IDECmdLine"/>
</Unit3>
</Units>
</ProjectOptions>
<CompilerOptions>

2
ide/main.pp
View File

@ -6383,6 +6383,8 @@ begin
if (GetActiveMode=nil) and (Count>0) then
ActiveModeName:=Modes[0].Name;
Assert(Assigned(DebugBossMgr.ProjectLink), 'CreateProjectObject: ProjectLink=Nil');
DebugBossMgr.ProjectLink.Project:=Result;
Result.MainProject:=true;
Result.OnFileBackup:=@MainBuildBoss.BackupFileForWrite;
Result.OnLoadProjectInfo:=@OnLoadProjectInfoFromXMLConfig;

317
ide/project.pp
View File

@ -47,12 +47,12 @@ uses
MemCheck,
{$ENDIF}
// RTL + FCL
Classes, SysUtils, TypInfo,
Classes, SysUtils, TypInfo, System.UITypes,
// LCL
LCLProc, Forms, Controls, Dialogs,
LCLProc, Forms, Dialogs,
// CodeTools
CodeToolsConfig, ExprEval, DefineTemplates, BasicCodeTools, CodeToolsCfgScript,
LinkScanner, CodeToolManager, CodeCache, CodeTree, FileProcs, StdCodeTools,
LinkScanner, CodeToolManager, CodeCache, CodeTree, StdCodeTools,
// LazUtils
FPCAdds, LazUtilities, FileUtil, LazFileUtils, LazFileCache, LazMethodList,
LazLoggerBase, FileReferenceList, LazUTF8, Laz2_XMLCfg, Maps, AvgLvlTree,
@ -60,9 +60,6 @@ uses
PropEdits, UnitResources, EditorSyntaxHighlighterDef, InputHistory,
CompOptsIntf, ProjectIntf, MacroIntf, MacroDefIntf, SrcEditorIntf,
IDEOptionsIntf, IDEOptEditorIntf, IDEDialogs, LazIDEIntf, PackageIntf,
// DebuggerIntf
DbgIntfDebuggerBase,
{$IFnDEF LCLNOGUI} IdeDebuggerOpts, IdeDebuggerBackendValueConv, Debugger,{$EndIf}
// IdeConfig
EnvironmentOpts, LazConf, TransferMacros, SearchPathProcs, IdeXmlConfigProcs,
IDECmdLine, IDEProcs, CompOptsModes, ModeMatrixOpts,
@ -706,6 +703,21 @@ type
property LclApp: Boolean read FLclApp;
end;
TProjectDebugLinkBase = class
private
protected
procedure Clear; virtual; abstract;
procedure BeforeReadProject; virtual; abstract;
procedure AfterReadProject; virtual; abstract;
procedure LoadFromLPI(aXMLConfig: TRttiXMLConfig; Path: string); virtual; abstract;
procedure LoadFromSession(aXMLConfig: TRttiXMLConfig; Path: string); virtual; abstract;
procedure SaveToLPI(aXMLConfig: TRttiXMLConfig; Path: string); virtual; abstract;
procedure SaveToSession(aXMLConfig: TRttiXMLConfig; Path: string); virtual; abstract;
public
//constructor Create;
//destructor Destroy; override;
end;
{ TProject }
TEndUpdateProjectEvent =
@ -730,23 +742,13 @@ type
FAllEditorsInfoList: TUnitEditorInfoList;
FAllEditorsInfoMap: TMap;
FAutoCreateForms: boolean;
FDebuggerLink: TProjectDebugLinkBase;
FChangeStampSaved: integer;
FDebuggerBackend: String;
{$IFnDEF LCLNOGUI}
FDebuggerProperties: TDebuggerPropertiesConfigList; // named entries
{$EndIf}
FEnableI18NForLFM: boolean;
FHistoryLists: THistoryLists;
FLastCompileComplete: boolean;
FMacroEngine: TTransferMacroList;
FOnLoadSafeCustomData: TLazLoadSaveCustomDataEvent;
FStoreBackendConverterConfigInSession: boolean;
FBackendConverterConfigWasFromSession, FBackendConverterConfigWasFromLPI: boolean;
{$IFnDEF LCLNOGUI}
FBackendConverterConfig: TIdeDbgValueConvertSelectorList;
{$EndIf}
FStoreDebuggerClassConfInSession: boolean;
FDebuggerClassConfWasFromSession, FDebuggerClassConfWasFromLPI: boolean;
FTmpAutoCreatedForms: TStrings; // temporary, used to apply auto create forms changes
FAutoOpenDesignerFormsDisabled: boolean;
FBookmarks: TProjectBookmarkList;
@ -798,8 +800,6 @@ type
FOtherDefines: TStrings; // list of user selectable defines for custom options
FUpdateLock: integer;
FUseAsDefault: Boolean;
FUseBackendConverterFromIDE: boolean;
FUseBackendConverterFromProject: boolean;
// Variables used by ReadProject / WriteProject
FXMLConfig: TRttiXMLConfig;
FLoadAllOptions: Boolean; // All options / just options used as default for new projects
@ -831,17 +831,11 @@ type
procedure EmbeddedObjectModified(Sender: TObject);
function FileBackupHandler(const Filename: string): TModalResult;
procedure LoadSaveFilenameHandler(var AFilename: string; Load: boolean);
procedure OnBackendConverterConfigChanged(Sender: TObject);
procedure SetStoreBackendConverterConfigInSession(AValue: boolean);
procedure SetStoreDebuggerClassConfInSession(AValue: boolean);
procedure SetUseBackendConverterFromIDE(AValue: boolean);
procedure SetUseBackendConverterFromProject(AValue: boolean);
procedure UnitNameChangeHandler(AnUnitInfo: TUnitInfo;
const OldUnitName, NewUnitName: string;
CheckIfAllowed: boolean; var Allowed: boolean);
procedure SetActiveBuildMode(const AValue: TProjectBuildMode);
procedure SetAutoOpenDesignerFormsDisabled(const AValue: boolean);
procedure SetDebuggerBackend(AValue: String);
procedure SetEnableI18N(const AValue: boolean);
procedure SetEnableI18NForLFM(const AValue: boolean);
procedure SetLastCompilerParams(AValue: TStrings);
@ -909,7 +903,7 @@ type
procedure SetSessionModified(const AValue: boolean); override;
procedure SetSessionStorage(const AValue: TProjectSessionStorage); override;
procedure SetUseManifest(AValue: boolean); override;
function GetCurrentDebuggerBackend: String; override;
//function GetCurrentDebuggerBackend: String; override;
protected
// special unit lists
procedure AddToList(AnUnitInfo: TUnitInfo; ListType: TUnitInfoList);
@ -1106,6 +1100,7 @@ type
property SkipCheckLCLInterfaces: boolean read FSkipCheckLCLInterfaces
write SetSkipCheckLCLInterfaces;
property CompilerOptions: TProjectCompilerOptions read GetCompilerOptions;
property DebuggerLink: TProjectDebugLinkBase read FDebuggerLink write FDebuggerLink;
property DefineTemplates: TProjectDefineTemplates read FDefineTemplates;
property Destroying: boolean read fDestroying;
property EnableI18N: boolean read FEnableI18N write SetEnableI18N;
@ -1165,26 +1160,6 @@ type
property OtherDefines: TStrings read FOtherDefines;
property UpdateLock: integer read FUpdateLock;
property UseAsDefault: Boolean read FUseAsDefault write FUseAsDefault; // for dialog only (used to store options once)
property DebuggerBackend: String read FDebuggerBackend write SetDebuggerBackend;
// Debugger
{$IFnDEF LCLNOGUI}
function DebuggerPropertiesConfigList: TDebuggerPropertiesConfigList;
function CurrentDebuggerClass: TDebuggerClass;
function DebuggerFilename: string;
function GetParsedDebuggerFilename: string;
function CurrentDebuggerPropertiesConfig: TDebuggerPropertiesConfig;
{$EndIf}
procedure MarkDebuggerClassConfAsModified;
property StoreDebuggerClassConfInSession: boolean read FStoreDebuggerClassConfInSession write SetStoreDebuggerClassConfInSession;
{$IFnDEF LCLNOGUI}
property BackendConverterConfig: TIdeDbgValueConvertSelectorList read FBackendConverterConfig write FBackendConverterConfig;
{$EndIf}
property StoreBackendConverterConfigInSession: boolean read FStoreBackendConverterConfigInSession write SetStoreBackendConverterConfigInSession;
property UseBackendConverterFromIDE: boolean read FUseBackendConverterFromIDE write SetUseBackendConverterFromIDE;
property UseBackendConverterFromProject: boolean read FUseBackendConverterFromProject write SetUseBackendConverterFromProject;
end;
@ -2212,7 +2187,7 @@ begin
if FSource<>nil then
fSourceChangeStep:=FSource.ChangeStep // Indicates any change is source
else
fSourceChangeStep:=CTInvalidChangeStamp;
fSourceChangeStep:=LUInvalidChangeStamp;
end;
function TUnitInfo.IsChangedOnDisk(CheckLFM: boolean): boolean;
@ -2838,17 +2813,6 @@ begin
FHistoryLists := THistoryLists.Create;
FLastCompilerParams := TStringListUTF8Fast.Create;
{$IFnDEF LCLNOGUI}
FDebuggerProperties := TDebuggerPropertiesConfigList.Create;
FBackendConverterConfig := TIdeDbgValueConvertSelectorList.Create;
FBackendConverterConfig.OnChanged := @OnBackendConverterConfigChanged;
{$EndIf}
FUseBackendConverterFromIDE := True;
FUseBackendConverterFromProject := True;
if DebugBossManager <> nil then
DebugBossManager.DoBackendConverterChanged;
end;
{------------------------------------------------------------------------------
@ -2879,11 +2843,6 @@ begin
FreeThenNil(FDefineTemplates);
FreeAndNil(FHistoryLists);
FreeAndNil(FLastCompilerParams);
{$IFnDEF LCLNOGUI}
FreeAndNil(FDebuggerProperties);
FreeAndNil(FBackendConverterConfig);
{$EndIf}
inherited Destroy;
end;
@ -3095,26 +3054,8 @@ begin
// load session info
LoadSessionInfo(Path,false);
FStoreDebuggerClassConfInSession := FXMLConfig.GetValue(Path+'Debugger/StoreDebuggerClassConfInSession/Value', False);
if not FStoreDebuggerClassConfInSession then begin
{$IFnDEF LCLNOGUI}
FDebuggerProperties.LoadFromXml(FXMLConfig, Path+'Debugger/ClassConfig/');
{$EndIf}
FDebuggerClassConfWasFromLPI := True;
end;
FStoreBackendConverterConfigInSession := FXMLConfig.GetValue(Path+'Debugger/StoreBackendConverterConfigInSession/Value', False);
if not FStoreBackendConverterConfigInSession then begin
{$IFnDEF LCLNOGUI}
FBackendConverterConfig.LoadDataFromXMLConfig(FXMLConfig, Path+'Debugger/BackendConv/');
ProjectValueConverterSelectorList := FBackendConverterConfig;
{$EndIf}
FBackendConverterConfigWasFromLPI := True;
end;
// This is for backward compatibility (only trunk 2.1 did use this / Can be removed in some time after 2.2 / but needs LoadFromSession to change default to '')
FDebuggerBackend := FXMLConfig.GetValue(Path+'Debugger/Backend/Value', '');
if Assigned(FDebuggerLink) then
FDebuggerLink.LoadFromLPI(FXMLConfig, Path);
// call hooks to read their info (e.g. DebugBoss)
if Assigned(OnLoadProjectInfo) then
OnLoadProjectInfo(Self, FXMLConfig, false);
@ -3147,26 +3088,8 @@ begin
if FFileVersion>=12 then
HistoryLists.LoadFromXMLConfig(FXMLConfig,Path+'HistoryLists/');
// Load from LPI will have been called first => so if session has no value, we keep the LPI value (as for some time, the data was stored in the LPI)
FDebuggerBackend := FXMLConfig.GetValue(Path+'Debugger/Backend/Value', FDebuggerBackend);
if FStoreDebuggerClassConfInSession then begin
{$IFnDEF LCLNOGUI}
FDebuggerProperties.LoadFromXml(FXMLConfig, Path+'Debugger/ClassConfig/');
{$EndIf}
FDebuggerClassConfWasFromSession := True;
end;
FUseBackendConverterFromIDE := FXMLConfig.GetValue(Path+'Debugger/BackendConvOpts/UseBackendConverterFromIDE', True);
FUseBackendConverterFromProject := FXMLConfig.GetValue(Path+'Debugger/BackendConvOpts/UseBackendConverterFromProject', True);
if FStoreBackendConverterConfigInSession then begin
{$IFnDEF LCLNOGUI}
FBackendConverterConfig.LoadDataFromXMLConfig(FXMLConfig, Path+'Debugger/BackendConv/');
ProjectValueConverterSelectorList := FBackendConverterConfig;
{$EndIf}
FBackendConverterConfigWasFromSession := True;
end;
if Assigned(FDebuggerLink) then
FDebuggerLink.LoadFromSession(FXMLConfig, Path);
// call hooks to read their info (e.g. DebugBoss)
if Assigned(OnLoadProjectInfo) then
OnLoadProjectInfo(Self,FXMLConfig,true);
@ -3184,7 +3107,7 @@ begin
ProjectInfoFile:=Filename;
PIFile:=ProjectInfoFile; // May be different from Filename, setter changed.
fProjectInfoFileBuffer:=CodeToolBoss.LoadFile(PIFile,true,true);
fProjectInfoFileBufChangeStamp:=CTInvalidChangeStamp;
fProjectInfoFileBufChangeStamp:=LUInvalidChangeStamp;
try
fProjectInfoFileDate:=FileAgeCached(PIFile);
{$IFDEF IDE_MEM_CHECK}CheckHeapWrtMemCnt('TProject.ReadProject A reading lpi');{$ENDIF}
@ -3309,8 +3232,8 @@ begin
Result := mrCancel;
BeginUpdate(true);
try
FDebuggerClassConfWasFromSession := False;
FDebuggerClassConfWasFromLPI := False;
if Assigned(FDebuggerLink) then
FDebuggerLink.BeforeReadProject;
BuildModes.FGlobalMatrixOptions := GlobalMatrixOptions;
FLoadAllOptions := LoadAllOptions;
@ -3336,10 +3259,8 @@ begin
FAllEditorsInfoList.SortByPageIndex;
end;
{$IFDEF IDE_MEM_CHECK}CheckHeapWrtMemCnt('TProject.ReadProject END');{$ENDIF}
if DebugBossManager <> nil then
DebugBossManager.DoBackendConverterChanged;
if Assigned(FDebuggerLink) then
FDebuggerLink.AfterReadProject;
Result := mrOk;
end;
@ -3486,29 +3407,8 @@ begin
// save units
SaveUnits(Path,FSaveSessionInLPI);
FXMLConfig.DeletePath(Path+'Debugger/Backend'); // remove old value from trunk 2.1
FXMLConfig.SetDeleteValue(Path+'Debugger/StoreDebuggerClassConfInSession/Value', FStoreDebuggerClassConfInSession, False);
if not FStoreDebuggerClassConfInSession then
{$IFnDEF LCLNOGUI}
FDebuggerProperties.SaveToXml(FXMLConfig, Path+'Debugger/ClassConfig/')
{$EndIf}
else
if FDebuggerClassConfWasFromLPI then
FXMLConfig.DeletePath(Path+'Debugger/ClassConfig');
FDebuggerClassConfWasFromSession := False;
FDebuggerClassConfWasFromLPI := False;
FXMLConfig.SetDeleteValue(Path+'Debugger/StoreBackendConverterConfigInSession/Value', FStoreBackendConverterConfigInSession, False);
if not FStoreBackendConverterConfigInSession then
{$IFnDEF LCLNOGUI}
FBackendConverterConfig.SaveDataToXMLConfig(FXMLConfig, Path+'Debugger/BackendConv/')
{$EndIf}
else
if FBackendConverterConfigWasFromLPI then
FXMLConfig.DeletePath(Path+'Debugger/BackendConv');
FBackendConverterConfigWasFromSession := False;
FBackendConverterConfigWasFromLPI := False;
if Assigned(FDebuggerLink) then
FDebuggerLink.SaveToLPI(FXMLConfig, Path);
if FSaveSessionInLPI then begin
// save defines used for custom options
@ -3564,30 +3464,8 @@ begin
// save all units
SaveUnits(Path,true);
FXMLConfig.SetDeleteValue(Path+'Debugger/Backend/Value', DebuggerBackend, '');
if FStoreDebuggerClassConfInSession then
{$IFnDEF LCLNOGUI}
FDebuggerProperties.SaveToXml(FXMLConfig, Path+'Debugger/ClassConfig/')
{$EndIf}
else
if FDebuggerClassConfWasFromSession then
FXMLConfig.DeletePath(Path+'Debugger/ClassConfig');
FDebuggerClassConfWasFromSession := False;
FDebuggerClassConfWasFromLPI := False;
FXMLConfig.SetDeleteValue(Path+'Debugger/BackendConvOpts/UseBackendConverterFromIDE', FUseBackendConverterFromIDE, True);
FXMLConfig.SetDeleteValue(Path+'Debugger/BackendConvOpts/UseBackendConverterFromProject', FUseBackendConverterFromProject, True);
if FStoreBackendConverterConfigInSession then
{$IFnDEF LCLNOGUI}
FBackendConverterConfig.SaveDataToXMLConfig(FXMLConfig, Path+'Debugger/BackendConv/')
{$EndIf}
else
if FBackendConverterConfigWasFromSession then
FXMLConfig.DeletePath(Path+'Debugger/BackendConv');
FBackendConverterConfigWasFromSession := False;
FBackendConverterConfigWasFromLPI := False;
if Assigned(FDebuggerLink) then
FDebuggerLink.SaveToSession(FXMLConfig, Path);
// save defines used for custom options
SaveOtherDefines(Path);
@ -4019,9 +3897,8 @@ begin
UpdateProjectDirectory;
FPublishOptions.Clear;
Title := '';
FUseBackendConverterFromIDE := True;
FUseBackendConverterFromProject := True;
if Assigned(FDebuggerLink) then
FDebuggerLink.Clear;
Modified := false;
SessionModified := false;
EndUpdate;
@ -4183,11 +4060,6 @@ begin
ProjResources.XPManifest.UseManifest:=AValue;
end;
function TProject.GetCurrentDebuggerBackend: String;
begin
Result := FDebuggerBackend;
end;
function TProject.UnitCount:integer;
begin
Result:=FUnitList.Count;
@ -4705,44 +4577,6 @@ begin
//debugln('TProject.OnLoadSaveFilename END "',AFilename,'" FileWasAbsolute=',dbgs(FileWasAbsolute));
end;
procedure TProject.OnBackendConverterConfigChanged(Sender: TObject);
begin
if FStoreBackendConverterConfigInSession then
SessionModified := True
else
Modified := True;
end;
procedure TProject.SetStoreBackendConverterConfigInSession(AValue: boolean);
begin
if FStoreBackendConverterConfigInSession = AValue then Exit;
FStoreBackendConverterConfigInSession := AValue;
Modified := True;
SessionModified := True;
end;
procedure TProject.SetStoreDebuggerClassConfInSession(AValue: boolean);
begin
if FStoreDebuggerClassConfInSession = AValue then Exit;
FStoreDebuggerClassConfInSession := AValue;
Modified := True;
SessionModified := True;
end;
procedure TProject.SetUseBackendConverterFromIDE(AValue: boolean);
begin
if FUseBackendConverterFromIDE = AValue then Exit;
FUseBackendConverterFromIDE := AValue;
SessionModified := True;
end;
procedure TProject.SetUseBackendConverterFromProject(AValue: boolean);
begin
if FUseBackendConverterFromProject = AValue then Exit;
FUseBackendConverterFromProject := AValue;
SessionModified := True;
end;
function TProject.RemoveProjectPathFromFilename(const AFilename: string): string;
var
ProjectPath:string;
@ -5547,70 +5381,6 @@ begin
SessionModified := true;
end;
{$IFnDEF LCLNOGUI}
function TProject.DebuggerPropertiesConfigList: TDebuggerPropertiesConfigList;
begin
Result := FDebuggerProperties;
end;
function TProject.CurrentDebuggerClass: TDebuggerClass;
var
DbgCfg: TDebuggerPropertiesConfig;
begin
Result := nil;
DbgCfg := CurrentDebuggerPropertiesConfig;
if DbgCfg<> nil then
Result := DbgCfg.DebuggerClass;
end;
function TProject.DebuggerFilename: string;
var
DbgCfg: TDebuggerPropertiesConfig;
begin
Result := '';
DbgCfg := CurrentDebuggerPropertiesConfig;
if DbgCfg <> nil then
Result := DbgCfg.DebuggerFilename;
end;
function TProject.GetParsedDebuggerFilename: string;
begin
Result := DebuggerOptions.GetParsedDebuggerFilename(DebuggerFilename);
end;
function TProject.CurrentDebuggerPropertiesConfig: TDebuggerPropertiesConfig;
begin
{$IFnDEF LCLNOGUI}
if Self = nil then
exit(DebuggerOptions.CurrentDebuggerPropertiesConfig);
Result := nil;
if (CurrentDebuggerBackend <> '') then
if (CurrentDebuggerBackend = 'IDE') then
Result := DebuggerOptions.CurrentDebuggerPropertiesConfig
else
Result := DebuggerOptions.CurrentDebuggerPropertiesConfigEx(CurrentDebuggerBackend);
if Result = nil then
Result := FDebuggerProperties.CurrentDebuggerPropertiesConfig;
// No project config?
if Result = nil then
Result := DebuggerOptions.CurrentDebuggerPropertiesConfig;
{$Else}
Result := nil;
{$EndIf}
end;
{$EndIf}
procedure TProject.MarkDebuggerClassConfAsModified;
begin
if FStoreDebuggerClassConfInSession then
SessionModified := True
else
Modified := True;
end;
procedure TProject.UnitNameChangeHandler(AnUnitInfo: TUnitInfo;
const OldUnitName, NewUnitName: string; CheckIfAllowed: boolean;
var Allowed: boolean);
@ -5683,13 +5453,6 @@ begin
FAutoOpenDesignerFormsDisabled:=AValue;
end;
procedure TProject.SetDebuggerBackend(AValue: String);
begin
if FDebuggerBackend = AValue then Exit;
FDebuggerBackend := AValue;
SessionModified := True;
end;
procedure TProject.SetEnableI18NForLFM(const AValue: boolean);
begin
if FEnableI18NForLFM=AValue then exit;
@ -6231,7 +5994,7 @@ begin
if fProjectInfoFileBuffer<>nil then
fProjectInfoFileBufChangeStamp:=fProjectInfoFileBuffer.ChangeStep
else
fProjectInfoFileBufChangeStamp:=CTInvalidChangeStamp;
fProjectInfoFileBufChangeStamp:=LUInvalidChangeStamp;
end;
procedure TProject.UpdateProjectDirectory;
@ -7357,7 +7120,7 @@ begin
inherited Create(AOwner);
fChangedHandlers:=TMethodList.Create;
fItems:=TFPList.Create;
FChangeStamp:=CTInvalidChangeStamp;
FChangeStamp:=LUInvalidChangeStamp;
fSavedChangeStamp:=FChangeStamp;
FSharedMatrixOptions:=TBuildMatrixOptions.Create;
FSharedMatrixOptions.OnChanged:=@OnItemChanged;
@ -7486,7 +7249,7 @@ end;
procedure TProjectBuildModes.IncreaseChangeStamp;
begin
CTIncreaseChangeStamp(FChangeStamp);
LUIncreaseChangeStamp(FChangeStamp);
if fChangedHandlers<>nil then fChangedHandlers.CallNotifyEvents(Self);
end;

307
ide/projectdebuglink.pas Normal file
View File

@ -0,0 +1,307 @@
unit ProjectDebugLink;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils,
// LazUtils
Laz2_XMLCfg, LazLoggerBase,
// DebuggerIntf
DbgIntfDebuggerBase,
// IdeDebugger
IdeDebuggerOpts, IdeDebuggerBackendValueConv, Debugger,
// IDE
Project;
type
{ TProjectDebugLink }
TProjectDebugLink = class(TProjectDebugLinkBase)
private
FProject: TProject;
FDebuggerProperties: TDebuggerPropertiesConfigList; // named entries
FDebuggerBackend: String;
FBackendConverterConfig: TIdeDbgValueConvertSelectorList;
FStoreDebuggerClassConfInSession: boolean;
FDebuggerClassConfWasFromSession, FDebuggerClassConfWasFromLPI: boolean;
FStoreBackendConverterConfigInSession: boolean;
FBackendConverterConfigWasFromSession, FBackendConverterConfigWasFromLPI: boolean;
FUseBackendConverterFromIDE: boolean;
FUseBackendConverterFromProject: boolean;
function GetCurrentDebuggerBackend: String;
procedure SetDebuggerBackend(AValue: String);
procedure SetProject(AValue: TProject);
procedure SetStoreDebuggerClassConfInSession(AValue: boolean);
procedure SetStoreBackendConverterConfigInSession(AValue: boolean);
procedure SetUseBackendConverterFromIDE(AValue: boolean);
procedure SetUseBackendConverterFromProject(AValue: boolean);
procedure BackendConverterConfigChanged(Sender: TObject);
protected
procedure Clear; override;
procedure BeforeReadProject; override;
procedure AfterReadProject; override;
procedure LoadFromLPI(aXMLConfig: TRttiXMLConfig; Path: string); override;
procedure LoadFromSession(aXMLConfig: TRttiXMLConfig; Path: string); override;
procedure SaveToLPI(aXMLConfig: TRttiXMLConfig; Path: string); override;
procedure SaveToSession(aXMLConfig: TRttiXMLConfig; Path: string); override;
public
constructor Create;
destructor Destroy; override;
public
function DebuggerPropertiesConfigList: TDebuggerPropertiesConfigList;
function CurrentDebuggerClass: TDebuggerClass;
function DebuggerFilename: string;
function GetParsedDebuggerFilename: string;
function CurrentDebuggerPropertiesConfig: TDebuggerPropertiesConfig;
procedure MarkDebuggerClassConfAsModified;
property Project: TProject read FProject write SetProject;
property CurrentDebuggerBackend: String read GetCurrentDebuggerBackend;
property DebuggerBackend: String read FDebuggerBackend write SetDebuggerBackend;
property StoreDebuggerClassConfInSession: boolean read FStoreDebuggerClassConfInSession
write SetStoreDebuggerClassConfInSession;
property BackendConverterConfig: TIdeDbgValueConvertSelectorList read FBackendConverterConfig
write FBackendConverterConfig;
property StoreBackendConverterConfigInSession: boolean read FStoreBackendConverterConfigInSession
write SetStoreBackendConverterConfigInSession;
property UseBackendConverterFromIDE: boolean read FUseBackendConverterFromIDE
write SetUseBackendConverterFromIDE;
property UseBackendConverterFromProject: boolean read FUseBackendConverterFromProject
write SetUseBackendConverterFromProject;
end;
implementation
{ TProjectDebugLink }
constructor TProjectDebugLink.Create;
begin
DebugLn(['TProjectDebugLink.Create: Project=', FProject]);
FDebuggerProperties := TDebuggerPropertiesConfigList.Create;
FBackendConverterConfig := TIdeDbgValueConvertSelectorList.Create;
FBackendConverterConfig.OnChanged := @BackendConverterConfigChanged;
FUseBackendConverterFromIDE := True;
FUseBackendConverterFromProject := True;
if DebugBossManager <> nil then
DebugBossManager.DoBackendConverterChanged;
end;
destructor TProjectDebugLink.Destroy;
begin
FreeAndNil(FDebuggerProperties);
FreeAndNil(FBackendConverterConfig);
inherited Destroy;
end;
function TProjectDebugLink.GetCurrentDebuggerBackend: String;
begin
Result := FDebuggerBackend;
end;
procedure TProjectDebugLink.SetDebuggerBackend(AValue: String);
begin
if FDebuggerBackend = AValue then Exit;
FDebuggerBackend := AValue;
FProject.SessionModified := True;
end;
procedure TProjectDebugLink.SetProject(AValue: TProject);
begin
// A new project can have the same address as a previous freed project and this test
//if FProject = AValue then Exit; // would prevent updating FProject.DebuggerLink.
FProject := AValue;
if Assigned(FProject) then
FProject.DebuggerLink := Self;
end;
procedure TProjectDebugLink.SetStoreDebuggerClassConfInSession(AValue: boolean);
begin
if FStoreDebuggerClassConfInSession = AValue then Exit;
FStoreDebuggerClassConfInSession := AValue;
FProject.Modified := True;
FProject.SessionModified := True;
end;
procedure TProjectDebugLink.SetStoreBackendConverterConfigInSession(AValue: boolean);
begin
if FStoreBackendConverterConfigInSession = AValue then Exit;
FStoreBackendConverterConfigInSession := AValue;
FProject.Modified := True;
FProject.SessionModified := True;
end;
procedure TProjectDebugLink.SetUseBackendConverterFromIDE(AValue: boolean);
begin
if FUseBackendConverterFromIDE = AValue then Exit;
FUseBackendConverterFromIDE := AValue;
FProject.SessionModified := True;
end;
procedure TProjectDebugLink.SetUseBackendConverterFromProject(AValue: boolean);
begin
if FUseBackendConverterFromProject = AValue then Exit;
FUseBackendConverterFromProject := AValue;
FProject.SessionModified := True;
end;
procedure TProjectDebugLink.BackendConverterConfigChanged(Sender: TObject);
begin
if FStoreBackendConverterConfigInSession then
FProject.SessionModified := True
else
FProject.Modified := True;
end;
procedure TProjectDebugLink.Clear;
begin
FUseBackendConverterFromIDE := True;
FUseBackendConverterFromProject := True;
end;
procedure TProjectDebugLink.BeforeReadProject;
begin
FDebuggerClassConfWasFromSession := False;
FDebuggerClassConfWasFromLPI := False;
end;
procedure TProjectDebugLink.AfterReadProject;
begin
if DebugBossManager <> nil then
DebugBossManager.DoBackendConverterChanged;
end;
procedure TProjectDebugLink.LoadFromLPI(aXMLConfig: TRttiXMLConfig; Path: string);
begin
FStoreDebuggerClassConfInSession := aXMLConfig.GetValue(Path+'Debugger/StoreDebuggerClassConfInSession/Value', False);
if not FStoreDebuggerClassConfInSession then begin
FDebuggerProperties.LoadFromXml(aXMLConfig, Path+'Debugger/ClassConfig/');
FDebuggerClassConfWasFromLPI := True;
end;
FStoreBackendConverterConfigInSession := aXMLConfig.GetValue(Path+'Debugger/StoreBackendConverterConfigInSession/Value', False);
if not FStoreBackendConverterConfigInSession then begin
FBackendConverterConfig.LoadDataFromXMLConfig(aXMLConfig, Path+'Debugger/BackendConv/');
ProjectValueConverterSelectorList := FBackendConverterConfig;
FBackendConverterConfigWasFromLPI := True;
end;
// This is for backward compatibility (only trunk 2.1 did use this / Can be removed in some time after 2.2 / but needs LoadFromSession to change default to '')
FDebuggerBackend := aXMLConfig.GetValue(Path+'Debugger/Backend/Value', '');
end;
procedure TProjectDebugLink.LoadFromSession(aXMLConfig: TRttiXMLConfig; Path: string);
begin
// Load from LPI will have been called first => so if session has no value, we keep the LPI value (as for some time, the data was stored in the LPI)
FDebuggerBackend := aXMLConfig.GetValue(Path+'Debugger/Backend/Value', FDebuggerBackend);
if FStoreDebuggerClassConfInSession then begin
FDebuggerProperties.LoadFromXml(aXMLConfig, Path+'Debugger/ClassConfig/');
FDebuggerClassConfWasFromSession := True;
end;
FUseBackendConverterFromIDE := aXMLConfig.GetValue(Path+'Debugger/BackendConvOpts/UseBackendConverterFromIDE', True);
FUseBackendConverterFromProject := aXMLConfig.GetValue(Path+'Debugger/BackendConvOpts/UseBackendConverterFromProject', True);
if FStoreBackendConverterConfigInSession then begin
FBackendConverterConfig.LoadDataFromXMLConfig(aXMLConfig, Path+'Debugger/BackendConv/');
ProjectValueConverterSelectorList := FBackendConverterConfig;
FBackendConverterConfigWasFromSession := True;
end;
end;
procedure TProjectDebugLink.SaveToLPI(aXMLConfig: TRttiXMLConfig; Path: string);
begin
aXMLConfig.DeletePath(Path+'Debugger/Backend'); // remove old value from trunk 2.1
aXMLConfig.SetDeleteValue(Path+'Debugger/StoreDebuggerClassConfInSession/Value', FStoreDebuggerClassConfInSession, False);
if not FStoreDebuggerClassConfInSession then
FDebuggerProperties.SaveToXml(aXMLConfig, Path+'Debugger/ClassConfig/')
else if FDebuggerClassConfWasFromLPI then
aXMLConfig.DeletePath(Path+'Debugger/ClassConfig');
FDebuggerClassConfWasFromSession := False;
FDebuggerClassConfWasFromLPI := False;
aXMLConfig.SetDeleteValue(Path+'Debugger/StoreBackendConverterConfigInSession/Value', FStoreBackendConverterConfigInSession, False);
if not FStoreBackendConverterConfigInSession then
FBackendConverterConfig.SaveDataToXMLConfig(aXMLConfig, Path+'Debugger/BackendConv/')
else if FBackendConverterConfigWasFromLPI then
aXMLConfig.DeletePath(Path+'Debugger/BackendConv');
FBackendConverterConfigWasFromSession := False;
FBackendConverterConfigWasFromLPI := False;
end;
procedure TProjectDebugLink.SaveToSession(aXMLConfig: TRttiXMLConfig; Path: string);
begin
aXMLConfig.SetDeleteValue(Path+'Debugger/Backend/Value', DebuggerBackend, '');
if FStoreDebuggerClassConfInSession then
FDebuggerProperties.SaveToXml(aXMLConfig, Path+'Debugger/ClassConfig/')
else if FDebuggerClassConfWasFromSession then
aXMLConfig.DeletePath(Path+'Debugger/ClassConfig');
FDebuggerClassConfWasFromSession := False;
FDebuggerClassConfWasFromLPI := False;
aXMLConfig.SetDeleteValue(Path+'Debugger/BackendConvOpts/UseBackendConverterFromIDE', FUseBackendConverterFromIDE, True);
aXMLConfig.SetDeleteValue(Path+'Debugger/BackendConvOpts/UseBackendConverterFromProject', FUseBackendConverterFromProject, True);
if FStoreBackendConverterConfigInSession then
FBackendConverterConfig.SaveDataToXMLConfig(aXMLConfig, Path+'Debugger/BackendConv/')
else if FBackendConverterConfigWasFromSession then
aXMLConfig.DeletePath(Path+'Debugger/BackendConv');
FBackendConverterConfigWasFromSession := False;
FBackendConverterConfigWasFromLPI := False;
end;
function TProjectDebugLink.DebuggerPropertiesConfigList: TDebuggerPropertiesConfigList;
begin
Result := FDebuggerProperties;
end;
function TProjectDebugLink.CurrentDebuggerClass: TDebuggerClass;
var
DbgCfg: TDebuggerPropertiesConfig;
begin
Result := nil;
DbgCfg := CurrentDebuggerPropertiesConfig;
if DbgCfg<> nil then
Result := DbgCfg.DebuggerClass;
end;
function TProjectDebugLink.DebuggerFilename: string;
var
DbgCfg: TDebuggerPropertiesConfig;
begin
Result := '';
DbgCfg := CurrentDebuggerPropertiesConfig;
if DbgCfg <> nil then
Result := DbgCfg.DebuggerFilename;
end;
function TProjectDebugLink.GetParsedDebuggerFilename: string;
begin
Result := DebuggerOptions.GetParsedDebuggerFilename(DebuggerFilename);
end;
function TProjectDebugLink.CurrentDebuggerPropertiesConfig: TDebuggerPropertiesConfig;
begin
if Self = nil then
exit(DebuggerOptions.CurrentDebuggerPropertiesConfig);
Result := nil;
if (CurrentDebuggerBackend <> '') then
if (CurrentDebuggerBackend = 'IDE') then
Result := DebuggerOptions.CurrentDebuggerPropertiesConfig
else
Result := DebuggerOptions.CurrentDebuggerPropertiesConfigEx(CurrentDebuggerBackend);
if Result = nil then
Result := FDebuggerProperties.CurrentDebuggerPropertiesConfig;
// No project config?
if Result = nil then
Result := DebuggerOptions.CurrentDebuggerPropertiesConfig;
end;
procedure TProjectDebugLink.MarkDebuggerClassConfAsModified;
begin
if FStoreDebuggerClassConfInSession then
FProject.SessionModified := True
else
FProject.Modified := True;
end;
end.