paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-11-19 22:29:37 +01:00
Code Issues Packages Projects Releases Wiki Activity

lazbuild: checking dependency graph

Browse Source 
git-svn-id: trunk@9815 -
This commit is contained in:
mattias 2006-09-05 11:36:29 +00:00
parent 2e614998a5
commit a7c0385d1a
19 changed files with 431 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ide/compileroptions.pp
View File

@ -329,7 +329,7 @@ type
function GetXMLConfigPath: String; virtual;
function CreateTargetFilename(const MainSourceFileName: string): string; virtual;
function GetTargetFileExt: string; virtual;
procedure GetInheritedCompilerOptions(var OptionsList: TList); virtual;
procedure GetInheritedCompilerOptions(var OptionsList: TFPList); virtual;
function GetOwnerName: string; virtual;
function GetInheritedOption(Option: TInheritedCompilerOption;
RelativeToBaseDir: boolean;
@ -466,7 +466,7 @@ function ParseString(Options: TParsedCompilerOptions;
const UnparsedValue: string;
PlatformIndependent: boolean): string;
procedure GatherInheritedOptions(AddOptionsList: TList;
procedure GatherInheritedOptions(AddOptionsList: TFPList;
Parsed: TCompilerOptionsParseType;
var InheritedOptionStrings: TInheritedCompOptsStrings);
function InheritedOptionsToCompilerParameters(
@ -518,7 +518,7 @@ begin
Result:=OnParseString(Options,UnparsedValue,PlatformIndependent);
end;
procedure GatherInheritedOptions(AddOptionsList: TList;
procedure GatherInheritedOptions(AddOptionsList: TFPList;
Parsed: TCompilerOptionsParseType;
var InheritedOptionStrings: TInheritedCompOptsStrings);
var
@ -1394,7 +1394,7 @@ begin
end;
procedure TBaseCompilerOptions.GetInheritedCompilerOptions(
var OptionsList: TList);
var OptionsList: TFPList);
begin
OptionsList:=nil;
end;
@ -1416,7 +1416,7 @@ function TBaseCompilerOptions.GetInheritedOption(
Option: TInheritedCompilerOption; RelativeToBaseDir: boolean;
Parsed: TCompilerOptionsParseType): string;
var
OptionsList: TList;
OptionsList: TFPList;
p: TCompilerOptionsParseType;
begin
if (fInheritedOptParseStamps<>CompilerParseStamp)

2
ide/compileroptionsdlg.pp
View File

@ -1075,7 +1075,7 @@ end;
procedure TfrmCompilerOptions.UpdateInheritedTab;
var
OptionsList: TList;
OptionsList: TFPList;
i: Integer;
AncestorOptions: TAdditionalCompilerOptions;
AncestorNode: TTreeNode;

16
ide/diskdiffsdialog.pas
View File

@ -61,27 +61,27 @@ type
Shift: TShiftState; X, Y: Integer);
procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
private
FUnitList: TList;
FCachedDiffs: TList; // List of PDiffItem
FUnitList: TFPList;
FCachedDiffs: TFPList; // List of PDiffItem
procedure FillFilesListBox;
procedure SetUnitList(const AValue: TList);
procedure SetUnitList(const AValue: TFPList);
procedure ShowDiff;
function GetCachedDiff(AnUnitInfo: TUnitInfo): PDiffItem;
procedure ClearCache;
public
property UnitList: TList read FUnitList write SetUnitList; // list of TUnitInfo
property UnitList: TFPList read FUnitList write SetUnitList; // list of TUnitInfo
constructor Create(TheOwner: TComponent); override;
destructor Destroy; override;
end;
function ShowDiskDiffsDialog(AnUnitList: TList): TModalResult;
function ShowDiskDiffsDialog(AnUnitList: TFPList): TModalResult;
implementation
var
DiskDiffsDlg: TDiskDiffsDlg = nil;
function ShowDiskDiffsDialog(AnUnitList: TList): TModalResult;
function ShowDiskDiffsDialog(AnUnitList: TFPList): TModalResult;
procedure CheckWithLoading;
var
@ -166,7 +166,7 @@ begin
FilesListBox.Items.EndUpdate;
end;
procedure TDiskDiffsDlg.SetUnitList(const AValue: TList);
procedure TDiskDiffsDlg.SetUnitList(const AValue: TFPList);
begin
FUnitList:=AValue;
FillFilesListBox;
@ -192,7 +192,7 @@ var
fs: TFileStream;
begin
if FCachedDiffs=nil then
FCachedDiffs:=TList.Create;
FCachedDiffs:=TFPList.Create;
for i:=0 to FCachedDiffs.Count-1 do begin
Result:=PDiffItem(FCachedDiffs[i]);
if (Result<>nil) and (Result^.UnitInfo=AnUnitInfo) then exit;

58
ide/ideprocs.pp
View File

@ -212,10 +212,13 @@ function CompareCaret(const FirstCaret, SecondCaret: TPoint): integer;
function CompareBoolean(b1, b2: boolean): integer;
function CompareStringPointerI(Data1, Data2: Pointer): integer;
procedure CheckList(List: TList; TestListNil, TestDoubles, TestNils: boolean);
procedure CheckList(List: TFPList; TestListNil, TestDoubles, TestNils: boolean);
procedure CheckEmptyListCut(List1, List2: TList);
function AnsiSearchInStringList(List: TStrings; const s: string): integer;
procedure ReverseList(List: TList);
procedure ReverseList(List: TFPList);
procedure FreeListObjects(List: TList; FreeList: boolean);
procedure FreeListObjects(List: TFPList; FreeList: boolean);
implementation
@ -1096,6 +1099,35 @@ begin
end;
end;
procedure CheckList(List: TFPList; TestListNil, TestDoubles, TestNils: boolean);
var
Cnt: Integer;
i: Integer;
CurItem: Pointer;
j: Integer;
begin
if List=nil then begin
if TestListNil then
RaiseException('CheckList List is Nil');
exit;
end;
Cnt:=List.Count;
if TestNils then begin
for i:=0 to Cnt-1 do
if List[i]=nil then
RaiseException('CheckList item is Nil');
end;
if TestDoubles then begin
for i:=0 to Cnt-2 do begin
CurItem:=List[i];
for j:=i+1 to Cnt-1 do begin
if List[j]=CurItem then
RaiseException('CheckList Double');
end;
end;
end;
end;
{-------------------------------------------------------------------------------
procedure CheckEmptyListCut(List1, List2: TList);
-------------------------------------------------------------------------------}
@ -1185,6 +1217,21 @@ begin
end;
end;
procedure ReverseList(List: TFPList);
var
i: Integer;
j: Integer;
begin
if List=nil then exit;
i:=0;
j:=List.Count-1;
while i<j do begin
List.Exchange(i,j);
inc(i);
dec(j);
end;
end;
procedure FreeListObjects(List: TList; FreeList: boolean);
var
i: Integer;
@ -1196,6 +1243,17 @@ begin
List.Free;
end;
procedure FreeListObjects(List: TFPList; FreeList: boolean);
var
i: Integer;
begin
for i:=0 to List.Count-1 do
TObject(List[i]).Free;
List.Clear;
if FreeList then
List.Free;
end;
{-------------------------------------------------------------------------------
function TrimSearchPath(const SearchPath, BaseDirectory: string): boolean;

95
ide/lazbuild.lpr
View File

@ -33,7 +33,7 @@ uses
// codetools
CodeToolManager, Laz_XMLCfg,
// IDEIntf
MacroIntf,
MacroIntf, PackageIntf,
// IDE
IDEProcs, InitialSetupDlgs, OutputFilter, Compiler, CompilerOptions,
TransferMacros, EnvironmentOpts, IDETranslations, LazarusIDEStrConsts,
@ -46,6 +46,8 @@ type
TLazBuildApplication = class(TCustomApplication)
private
FBuildAll: boolean;
FBuildRecursive: boolean;
fInitialized: boolean;
fInitResult: boolean;
TheOutputFilter: TOutputFilter;
@ -55,7 +57,6 @@ type
ErrorOccurred: boolean);
procedure OnExtToolNeedsOutputFilter(var OutputFilter: TOutputFilter;
var Abort: boolean);
procedure OnCmdLineCreate(var CmdLine: string; var Abort: boolean);
// global package functions
procedure GetDependencyOwnerDescription(Dependency: TPkgDependency;
@ -70,6 +71,9 @@ type
function BuildFile(Filename: string): boolean;
function BuildPackage(const AFilename: string): boolean;
function LoadPackage(const AFilename: string): TLazPackage;
procedure CompilePackage(APackage: TLazPackage; Flags: TPkgCompileFlags);
procedure CheckPackageGraphForCompilation(APackage: TLazPackage;
FirstDependency: TPkgDependency);
function Init: boolean;
procedure LoadEnvironmentOptions;
procedure SetupOutputFilter;
@ -83,8 +87,11 @@ type
function ParseParameters: boolean;
procedure WriteUsage;
procedure Error(ErrorCode: Byte; const ErrorMsg: string);
property BuildAll: boolean read FBuildAll write FBuildAll;// build all files of project/package
property BuildRecursive: boolean read FBuildRecursive // apply BuildAll flag to dependencies
write FBuildRecursive;
end;
const
ErrorFileNotFound = 1;
ErrorBuildFailed = 2;
@ -96,7 +103,7 @@ const
procedure TLazBuildApplication.OnExtToolFreeOutputFilter(
OutputFilter: TOutputFilter; ErrorOccurred: boolean);
begin
OutputFilter:=TheOutputFilter;
if ErrorOccurred then Error(ErrorBuildFailed,'tool reported error');
end;
procedure TLazBuildApplication.OnExtToolNeedsOutputFilter(
@ -105,13 +112,6 @@ begin
OutputFilter:=TheOutputFilter;
end;
procedure TLazBuildApplication.OnCmdLineCreate(var CmdLine: string;
var Abort: boolean);
// replace all transfer macros in command line
begin
Abort:=not GlobalMacroList.SubstituteStr(CmdLine);
end;
procedure TLazBuildApplication.GetDependencyOwnerDescription(
Dependency: TPkgDependency; var Description: string);
begin
@ -167,13 +167,19 @@ end;
function TLazBuildApplication.BuildPackage(const AFilename: string): boolean;
var
APackage: TLazPackage;
Flags: TPkgCompileFlags;
begin
Result:=false;
Init;
APackage:=LoadPackage(AFilename);
if APackage=nil then
Error(ErrorLoadPackageFailed, 'unable to load package "'+AFilename+'"');
Flags:=[];
if BuildAll then
Include(Flags,pcfCleanCompile);
if BuildRecursive and BuildAll then
Include(Flags,pcfCompileDependenciesClean);
CompilePackage(APackage,Flags);
end;
function TLazBuildApplication.LoadPackage(const AFilename: string): TLazPackage;
@ -212,6 +218,58 @@ begin
PkgLinks.SaveUserLinks;
end;
procedure TLazBuildApplication.CompilePackage(APackage: TLazPackage;
Flags: TPkgCompileFlags);
begin
if APackage.AutoCreated then
Error(ErrorBuildFailed,APackage.IDAsString+' is an auto created package');
// check graph for circles and broken dependencies
if not (pcfDoNotCompileDependencies in Flags) then begin
CheckPackageGraphForCompilation(APackage,nil);
end;
{$NOTE TODO: move code from package manager to packagegraph and use it here}
end;
procedure TLazBuildApplication.CheckPackageGraphForCompilation(
APackage: TLazPackage; FirstDependency: TPkgDependency);
function PathListToString(PathList: TFPList): string;
var
Dependency: TPkgDependency;
i: Integer;
begin
Result:='';
for i:=0 to PathList.Count-1 do begin
Dependency:=TPkgDependency(PathList[0]);
if Dependency is TPkgDependency then begin
if Result<>'' then
Result:=Result+'>';
Result:=Result+Dependency.AsString;
end;
end;
end;
var
PathList: TFPList;
begin
PathList:=nil;
try
// check for broken dependencies
PathList:=PackageGraph.FindBrokenDependencyPath(APackage,FirstDependency);
if PathList<>nil then
Error(ErrorLoadPackageFailed,'Broken dependency: '+PathListToString(PathList));
// check for circle dependencies
PathList:=PackageGraph.FindCircleDependencyPath(APackage,FirstDependency);
if PathList<>nil then
Error(ErrorLoadPackageFailed,'Circle dependency: '+PathListToString(PathList));
finally
PathList.Free;
end;
end;
function TLazBuildApplication.Init: boolean;
var
InteractiveSetup: Boolean;
@ -348,7 +406,9 @@ begin
LongOptions.Add('secondary-config-path');
LongOptions.Add('scp');
LongOptions.Add('language');
ErrorMsg:=CheckOptions('l',LongOptions,Options,NonOptions);
LongOptions.Add('build-all');
LongOptions.Add('recursive');
ErrorMsg:=CheckOptions('lBR',LongOptions,Options,NonOptions);
if ErrorMsg<>'' then begin
writeln(ErrorMsg);
writeln('');
@ -373,6 +433,12 @@ begin
SetPrimaryConfigPath(GetOptionValue('secondary-config-path'))
else if HasOption('scp') then
SetSecondaryConfigPath(GetOptionValue('scp'));
// build all
if HasOption('B','build-all') then
BuildAll:=true;
if HasOption('R','recursive') then
BuildRecursive:=true;
finally
Options.Free;
NonOptions.Free;
@ -393,6 +459,9 @@ begin
writeln('');
writeln('--help or -? ', listhisHelpMessage);
writeln('');
writeln('-B or --buildall ','build all files of project/package');
writeln('-R or --recursive ','apply build flags (-B) to dependencies too.');
writeln('');
writeln(PrimaryConfPathOptLong,' <path>');
writeln('or ',PrimaryConfPathOptShort,' <path>');
writeln(BreakString(space+lisprimaryConfigDirectoryWhereLazarusStoresItsConfig,

2
ide/lazdoc.pas
View File

@ -201,7 +201,7 @@ var
procedure CheckIfInAPackage;
var
PkgList: TList;
PkgList: TFPList;
i: Integer;
Dirs: String;
APackage: TLazPackage;

6
ide/main.pp
View File

@ -8762,7 +8762,7 @@ end;
function TMainIDE.DoCheckFilesOnDisk(Instantaneous: boolean): TModalResult;
var
AnUnitList: TList; // list of TUnitInfo
AnUnitList: TFPList; // list of TUnitInfo
i: integer;
CurUnit: TUnitInfo;
begin
@ -10570,7 +10570,7 @@ var
NewSource: TCodeBuffer;
NewX, NewY, NewTopLine: integer;
LogCaretXY, DeclarationCaretXY: TPoint;
OwnerList: TList;
OwnerList: TFPList;
ExtraFiles: TStrings;
Files: TStringList;
Identifier: string;
@ -10621,7 +10621,7 @@ begin
case Options.Scope of
frProject:
begin
OwnerList:=TList.Create;
OwnerList:=TFPList.Create;
OwnerList.Add(Project1);
end;
frOwnerProjectPackage,frAllOpenProjectsAndPackages:

20
ide/project.pp
View File

@ -291,7 +291,7 @@ type
destructor Destroy; override;
function GetOwnerName: string; override;
function GetDefaultMainSourceFileName: string; override;
procedure GetInheritedCompilerOptions(var OptionsList: TList); override;
procedure GetInheritedCompilerOptions(var OptionsList: TFPList); override;
procedure Assign(Source: TPersistent); override;
procedure CreateDiff(CompOpts: TBaseCompilerOptions;
Tool: TCompilerDiffTool); override;
@ -471,7 +471,7 @@ type
FStateFileDate: longint;
FStateFlags: TLazProjectStateFlags;
FTargetFileExt: String;
FUnitList: TList; // list of _all_ units (TUnitInfo)
FUnitList: TFPList; // list of _all_ units (TUnitInfo)
FUpdateLock: integer;
function GetFirstAutoRevertLockedUnit: TUnitInfo;
function GetFirstLoadedUnit: TUnitInfo;
@ -534,7 +534,7 @@ type
function IsVirtual: boolean;
function SomethingModified(CheckData, CheckSession: boolean): boolean;
procedure MainSourceFilenameChanged;
procedure GetUnitsChangedOnDisk(var AnUnitList: TList);
procedure GetUnitsChangedOnDisk(var AnUnitList: TFPList);
function ReadProject(const NewProjectInfoFile: string): TModalResult;
function WriteProject(ProjectWriteFlags: TProjectWriteFlags;
const OverrideProjectInfoFile: string): TModalResult;
@ -626,7 +626,7 @@ type
procedure MoveRequiredDependencyUp(Dependency: TPkgDependency);
procedure MoveRequiredDependencyDown(Dependency: TPkgDependency);
function Requires(APackage: TLazPackage): boolean;
procedure GetAllRequiredPackages(var List: TList);
procedure GetAllRequiredPackages(var List: TFPList);
procedure AddPackageDependency(const PackageName: string); override;
// paths
@ -1457,7 +1457,7 @@ begin
FRunParameterOptions:=TRunParamsOptions.Create;
FTargetFileExt := GetExecutableExt;
Title := '';
FUnitList := TList.Create; // list of TUnitInfo
FUnitList := TFPList.Create; // list of TUnitInfo
end;
{------------------------------------------------------------------------------
@ -2915,7 +2915,7 @@ begin
ExtendPath(SrcPathMacroName,CompilerOptions.SrcPath);
end;
procedure TProject.GetUnitsChangedOnDisk(var AnUnitList: TList);
procedure TProject.GetUnitsChangedOnDisk(var AnUnitList: TFPList);
var
AnUnitInfo: TUnitInfo;
begin
@ -2924,7 +2924,7 @@ begin
while (AnUnitInfo<>nil) do begin
if AnUnitInfo.ChangedOnDisk(false) then begin
if AnUnitList=nil then
AnUnitList:=TList.Create;
AnUnitList:=TFPList.Create;
AnUnitList.Add(AnUnitInfo);
end;
AnUnitInfo:=AnUnitInfo.fNext[uilAutoRevertLocked];
@ -3056,7 +3056,7 @@ begin
APackage)<>nil;
end;
procedure TProject.GetAllRequiredPackages(var List: TList);
procedure TProject.GetAllRequiredPackages(var List: TFPList);
begin
if Assigned(OnGetAllRequiredPackages) then
OnGetAllRequiredPackages(FirstRequiredDependency,List);
@ -3828,9 +3828,9 @@ begin
end;
procedure TProjectCompilerOptions.GetInheritedCompilerOptions(
var OptionsList: TList);
var OptionsList: TFPList);
var
PkgList: TList;
PkgList: TFPList;
begin
PkgList:=nil;
OwnerProject.GetAllRequiredPackages(PkgList);

3
ide/transfermacros.pp
View File

@ -313,9 +313,6 @@ begin
exit;
end;
end;
if MacroName='CompPath' then begin
writeln('TTransferMacroList.SubstituteStr MacroName=',MacroName,' Handled=',Handled);
end;
if (not Handled) and (AMacro<>nil) and (Assigned(AMacro.MacroFunction))
then begin
MacroStr:=AMacro.MacroFunction(MacroParam,Data,Abort);

6
ideintf/packageintf.pas
View File

@ -63,9 +63,9 @@ type
function AddUnitDependenciesForComponentClasses(const UnitFilename: string;
ComponentClassnames: TStrings): TModalResult; virtual; abstract;
function GetOwnersOfUnit(const UnitFilename: string): TList; virtual; abstract;
procedure ExtendOwnerListWithUsedByOwners(OwnerList: TList); virtual; abstract;
function GetSourceFilesOfOwners(OwnerList: TList): TStrings; virtual; abstract;
function GetOwnersOfUnit(const UnitFilename: string): TFPList; virtual; abstract;
procedure ExtendOwnerListWithUsedByOwners(OwnerList: TFPList); virtual; abstract;
function GetSourceFilesOfOwners(OwnerList: TFPList): TStrings; virtual; abstract;
end;
var

2
packager/basepkgmanager.pas
View File

@ -106,7 +106,7 @@ type
function DoCloseAllPackageEditors: TModalResult; virtual; abstract;
// package graph
procedure DoShowPackageGraphPathList(PathList: TList); virtual; abstract;
procedure DoShowPackageGraphPathList(PathList: TFPList); virtual; abstract;
procedure RebuildDefineTemplates; virtual; abstract;
// package compilation

6
packager/brokendependenciesdlg.pas
View File

@ -57,7 +57,7 @@ type
procedure SetupComponents;
procedure ClearButtons;
public
DependencyList: TList;
DependencyList: TFPList;
constructor Create(TheOwner: TComponent); override;
destructor Destroy; override;
property Buttons[Btn: TMsgDlgBtn]: TBitBtn read GetButtons;
@ -69,14 +69,14 @@ const
DefaultBrokenDepButtons = [mbYes,mbIgnore,mbCancel,mbAbort];
function ShowBrokenDependencies(DependencyList: TList;
function ShowBrokenDependencies(DependencyList: TFPList;
BtnSet: TMsgDlgButtons): TModalResult;
implementation
function ShowBrokenDependencies(DependencyList: TList;
function ShowBrokenDependencies(DependencyList: TFPList;
BtnSet: TMsgDlgButtons): TModalResult;
var
BrokenDependenciesDialog: TBrokenDependenciesDialog;

32
packager/installpkgsetdlg.pas
View File

@ -46,7 +46,7 @@ uses
type
TOnCheckInstallPackageList =
procedure(PkgIDs: TList; var Ok: boolean) of object;
procedure(PkgIDs: TFPList; var Ok: boolean) of object;
{ TInstallPkgSetDialog }
@ -76,7 +76,7 @@ type
procedure SaveAndExitButtonClick(Sender: TObject);
procedure UninstallButtonClick(Sender: TObject);
private
FNewInstalledPackages: TList;
FNewInstalledPackages: TFPList;
FOldInstalledPackages: TPkgDependency;
FOnCheckInstallPackageList: TOnCheckInstallPackageList;
fPackages: TAVLTree;// tree of TLazPackageID (all available packages and links)
@ -98,10 +98,10 @@ type
procedure SavePackageListToFile(const AFilename: string);
procedure LoadPackageListFromFile(const AFilename: string);
public
function GetNewInstalledPackages: TList;
function GetNewInstalledPackages: TFPList;
property OldInstalledPackages: TPkgDependency read FOldInstalledPackages
write SetOldInstalledPackages;
property NewInstalledPackages: TList read FNewInstalledPackages;
property NewInstalledPackages: TFPList read FNewInstalledPackages;
property RebuildIDE: boolean read FRebuildIDE write FRebuildIDE;
property OnCheckInstallPackageList: TOnCheckInstallPackageList
read FOnCheckInstallPackageList write FOnCheckInstallPackageList;
@ -109,14 +109,14 @@ type
function ShowEditInstallPkgsDialog(OldInstalledPackages: TPkgDependency;
CheckInstallPackageList: TOnCheckInstallPackageList;
var NewInstalledPackages: TList; // list of TLazPackageID (must be freed)
var NewInstalledPackages: TFPList; // list of TLazPackageID (must be freed)
var RebuildIDE: boolean): TModalResult;
implementation
function ShowEditInstallPkgsDialog(OldInstalledPackages: TPkgDependency;
CheckInstallPackageList: TOnCheckInstallPackageList;
var NewInstalledPackages: TList; // list of TLazPackageID
var NewInstalledPackages: TFPList; // list of TLazPackageID
var RebuildIDE: boolean): TModalResult;
var
InstallPkgSetDialog: TInstallPkgSetDialog;
@ -152,7 +152,7 @@ begin
CancelButton.Caption:=dlgCancel;
fPackages:=TAVLTree.Create(@CompareLazPackageIDNames);
FNewInstalledPackages:=TList.Create;
FNewInstalledPackages:=TFPList.Create;
PkgInfoMemo.Clear;
end;
@ -221,9 +221,9 @@ var
NewPackageID: TLazPackageID;
j: LongInt;
APackage: TLazPackage;
Additions: TList;
Additions: TFPList;
begin
Additions:=TList.Create;
Additions:=TFPList.Create;
NewPackageID:=TLazPackageID.Create;
try
for i:=0 to AvailableListBox.Items.Count-1 do begin
@ -324,9 +324,9 @@ var
i: Integer;
OldPackageID: TLazPackageID;
APackage: TLazPackage;
Deletions: TList;
Deletions: TFPList;
begin
Deletions:=TList.Create;
Deletions:=TFPList.Create;
try
for i:=0 to InstallListBox.Items.Count-1 do begin
if not InstallListBox.Selected[i] then continue;
@ -617,7 +617,7 @@ end;
procedure TInstallPkgSetDialog.LoadPackageListFromFile(const AFilename: string
);
function PkgNameExists(List: TList; ID: TLazPackageID): boolean;
function PkgNameExists(List: TFPList; ID: TLazPackageID): boolean;
var
i: Integer;
LazPackageID: TLazPackageID;
@ -638,7 +638,7 @@ var
i: Integer;
LazPackageID: TLazPackageID;
NewCount: LongInt;
NewList: TList;
NewList: TFPList;
ID: String;
begin
NewList:=nil;
@ -657,7 +657,7 @@ begin
// ignore doubles
if PkgNameExists(NewList,LazPackageID) then continue;
// add
if NewList=nil then NewList:=TList.Create;
if NewList=nil then NewList:=TFPList.Create;
NewList.Add(LazPackageID);
LazPackageID:=TLazPackageID.Create;
end;
@ -687,12 +687,12 @@ begin
end;
end;
function TInstallPkgSetDialog.GetNewInstalledPackages: TList;
function TInstallPkgSetDialog.GetNewInstalledPackages: TFPList;
var
i: Integer;
NewPackageID: TLazPackageID;
begin
Result:=TList.Create;
Result:=TFPList.Create;
for i:=0 to FNewInstalledPackages.Count-1 do begin
NewPackageID:=TLazPackageID.Create;
NewPackageID.AssignID(TLazPackageID(FNewInstalledPackages[i]));

68
packager/packagedefs.pas
View File

@ -62,7 +62,7 @@ type
TIteratePackagesEvent =
procedure(APackage: TLazPackageID) of object;
TGetAllRequiredPackagesEvent =
procedure(FirstDependency: TPkgDependency; var List: TList) of object;
procedure(FirstDependency: TPkgDependency; var List: TFPList) of object;
TGetDependencyOwnerDescription =
procedure(Dependency: TPkgDependency; var Description: string) of object;
TGetDependencyOwnerDirectory =
@ -148,7 +148,7 @@ type
private
FAutoReferenceSourceDir: boolean;
FComponentPriority: TComponentPriority;
FComponents: TList; // list of TPkgComponent
FComponents: TFPList; // list of TPkgComponent
FDirectory: string;
FRemoved: boolean;
FFilename: string;
@ -169,7 +169,7 @@ type
procedure SetFlags(const AValue: TPkgFileFlags);
procedure SetHasRegisterProc(const AValue: boolean);
procedure UpdateUnitName;
function GetComponentList: TList;
function GetComponentList: TFPList;
public
constructor Create(ThePackage: TLazPackage);
destructor Destroy; override;
@ -367,7 +367,7 @@ type
public
constructor Create(const AOwner: TObject); override;
procedure Clear; override;
procedure GetInheritedCompilerOptions(var OptionsList: TList); override;
procedure GetInheritedCompilerOptions(var OptionsList: TFPList); override;
function GetOwnerName: string; override;
procedure InvalidateOptions;
function GetDefaultMainSourceFileName: string; override;
@ -554,13 +554,13 @@ type
FAutoInstall: TPackageInstallType;
FAutoUpdate: TPackageUpdatePolicy;
FCompilerOptions: TPkgCompilerOptions;
FComponents: TList; // TList of TPkgComponent
FComponents: TFPList; // TFPList of TPkgComponent
FDefineTemplates: TLazPackageDefineTemplates;
FDescription: string;
FDirectory: string;
FFilename: string;
FFileReadOnly: boolean;
FFiles: TList; // TList of TPkgFile
FFiles: TFPList; // TFPList of TPkgFile
FFirstRemovedDependency: TPkgDependency;
FFirstRequiredDependency: TPkgDependency;
FFirstUsedByDependency: TPkgDependency;
@ -581,7 +581,7 @@ type
FPackageEditor: TBasePackageEditor;
FPackageType: TLazPackageType;
fPublishOptions: TPublishPackageOptions;
FRemovedFiles: TList; // TList of TPkgFile
FRemovedFiles: TFPList; // TFPList of TPkgFile
FRegistered: boolean;
FSourceDirectories: TFileReferenceList;
FStateFileDate: longint;
@ -645,7 +645,7 @@ type
function HasStaticDirectory: boolean;
function GetResolvedFilename: string;
function GetSourceDirs(WithPkgDir, WithoutOutputDir: boolean): string;
procedure GetInheritedCompilerOptions(var OptionsList: TList);
procedure GetInheritedCompilerOptions(var OptionsList: TFPList);
function GetCompileSourceFilename: string;
function GetOutputDirectory: string;
function GetStateFilename: string;
@ -698,7 +698,7 @@ type
procedure MoveRequiredDependencyDown(Dependency: TPkgDependency);
function CreateDependencyWithOwner(NewOwner: TObject): TPkgDependency;
function Requires(APackage: TLazPackage): boolean;
procedure GetAllRequiredPackages(var List: TList);
procedure GetAllRequiredPackages(var List: TFPList);
// components
function IndexOfPkgComponent(PkgComponent: TPkgComponent): integer;
function AddComponent(PkgFile: TPkgFile; const Page: string;
@ -831,7 +831,7 @@ function ComparePackageWithUnitsTree(Package: TLazPackage;
UnitTree: TPkgUnitsTree): integer;
function ComparePkgFilesAlphabetically(PkgFile1, PkgFile2: TPkgFile): integer;
function GetUsageOptionsList(PackageList: TList): TList;
function GetUsageOptionsList(PackageList: TFPList): TFPList;
function PkgFileTypeIdentToType(const s: string): TPkgFileType;
function LazPackageTypeIdentToType(const s: string): TLazPackageType;
@ -839,13 +839,13 @@ function GetPkgFileTypeLocalizedName(FileType: TPkgFileType): string;
function NameToAutoUpdatePolicy(const s: string): TPackageUpdatePolicy;
function FileNameToPkgFileType(const AFilename: string): TPkgFileType;
procedure SortDependencyList(Dependencies: TList);
procedure SortDependencyList(Dependencies: TFPList);
procedure LoadPkgDependencyList(XMLConfig: TXMLConfig; const ThePath: string;
var First: TPkgDependency; ListType: TPkgDependencyList; Owner: TObject;
HoldPackages: boolean);
procedure SavePkgDependencyList(XMLConfig: TXMLConfig; const ThePath: string;
First: TPkgDependency; ListType: TPkgDependencyList);
procedure ListPkgIDToDependencyList(ListOfTLazPackageID: TList;
procedure ListPkgIDToDependencyList(ListOfTLazPackageID: TFPList;
var First: TPkgDependency; ListType: TPkgDependencyList; Owner: TObject;
HoldPackages: boolean);
procedure FreeDependencyList(var First: TPkgDependency;
@ -934,12 +934,12 @@ var
i: Integer;
PkgDependency: TPkgDependency;
NewCount: Integer;
List: TList;
List: TFPList;
FileVersion: Integer;
begin
FileVersion:=XMLConfig.GetValue(ThePath+'Version',0);
NewCount:=XMLConfig.GetValue(ThePath+'Count',0);
List:=TList.Create;
List:=TFPList.Create;
for i:=0 to NewCount-1 do begin
PkgDependency:=TPkgDependency.Create;
PkgDependency.LoadFromXMLConfig(XMLConfig,ThePath+'Item'+IntToStr(i+1)+'/',
@ -974,7 +974,7 @@ begin
XMLConfig.SetDeleteValue(ThePath+'Count',i,0);
end;
procedure ListPkgIDToDependencyList(ListOfTLazPackageID: TList;
procedure ListPkgIDToDependencyList(ListOfTLazPackageID: TFPList;
var First: TPkgDependency; ListType: TPkgDependencyList; Owner: TObject;
HoldPackages: boolean);
var
@ -1015,7 +1015,7 @@ begin
end;
end;
procedure SortDependencyList(Dependencies: TList);
procedure SortDependencyList(Dependencies: TFPList);
var
Count: Integer;
i, j: Integer;
@ -1151,7 +1151,7 @@ begin
Result:=CompareFilenames(PkgFile1.FileName,PkgFile2.FileName);
end;
function GetUsageOptionsList(PackageList: TList): TList;
function GetUsageOptionsList(PackageList: TFPList): TFPList;
// returns a list of TPkgAdditionalCompilerOptions
// from the list of TLazPackage
var
@ -1159,7 +1159,7 @@ var
i: Integer;
begin
if PackageList<>nil then begin
Result:=TList.Create;
Result:=TFPList.Create;
Cnt:=PackageList.Count;
for i:=0 to Cnt-1 do begin
Result.Add(TLazPackage(PackageList[i]).UsageOptions);
@ -1379,9 +1379,9 @@ begin
FUnitName:='';
end;
function TPkgFile.GetComponentList: TList;
function TPkgFile.GetComponentList: TFPList;
begin
if FComponents=nil then FComponents:=TList.Create;
if FComponents=nil then FComponents:=TFPList.Create;
Result:=FComponents;
end;
@ -1512,7 +1512,7 @@ end;
procedure TPkgFile.AddPkgComponent(APkgComponent: TPkgComponent);
begin
if FComponents=nil then FComponents:=TList.Create;
if FComponents=nil then FComponents:=TFPList.Create;
FComponents.Add(APkgComponent);
if LazPackage<>nil then
LazPackage.AddPkgComponent(APkgComponent);
@ -2013,7 +2013,7 @@ end;
procedure TLazPackage.WriteInheritedUnparsedOptions;
var
OptionsList: TList;
OptionsList: TFPList;
AddOptions: TAdditionalCompilerOptions;
i: Integer;
begin
@ -2228,11 +2228,11 @@ end;
constructor TLazPackage.Create;
begin
inherited Create;
FComponents:=TList.Create;
FComponents:=TFPList.Create;
FSourceDirectories:=TFileReferenceList.Create;
FSourceDirectories.OnChanged:=@SourceDirectoriesChanged;
FFiles:=TList.Create;
FRemovedFiles:=TList.Create;
FFiles:=TFPList.Create;
FRemovedFiles:=TFPList.Create;
FMacros:=TTransferMacroList.Create;
FMacros.MarkUnhandledMacros:=false;
FMacros.OnSubstitution:=@OnMacroListSubstitution;
@ -2389,7 +2389,7 @@ var
OldFilename: String;
PathDelimChanged: boolean;
procedure LoadFiles(const ThePath: string; List: TList);
procedure LoadFiles(const ThePath: string; List: TFPList);
var
i: Integer;
NewCount: Integer;
@ -2460,7 +2460,7 @@ end;
procedure TLazPackage.SaveToXMLConfig(XMLConfig: TXMLConfig; const Path: string
);
procedure SaveFiles(const ThePath: string; List: TList);
procedure SaveFiles(const ThePath: string; List: TFPList);
var
i: Integer;
PkgFile: TPkgFile;
@ -2824,12 +2824,12 @@ end;
procedure TLazPackage.SortFiles;
var
NewList: TList;
NewList: TFPList;
Cnt: Integer;
i: Integer;
begin
if FileCount=0 then exit;
NewList:=TList.Create;
NewList:=TFPList.Create;
try
Cnt:=FileCount;
for i:=0 to Cnt-1 do NewList.Add(FFiles[i]);
@ -3049,15 +3049,15 @@ begin
Name:=NewName;
end;
procedure TLazPackage.GetAllRequiredPackages(var List: TList);
procedure TLazPackage.GetAllRequiredPackages(var List: TFPList);
begin
if Assigned(OnGetAllRequiredPackages) then
OnGetAllRequiredPackages(FirstRequiredDependency,List);
end;
procedure TLazPackage.GetInheritedCompilerOptions(var OptionsList: TList);
procedure TLazPackage.GetInheritedCompilerOptions(var OptionsList: TFPList);
var
PkgList: TList; // list of TLazPackage
PkgList: TFPList; // list of TLazPackage
begin
PkgList:=nil;
GetAllRequiredPackages(PkgList);
@ -3418,8 +3418,8 @@ begin
FSkipCompiler:=false;
end;
procedure TPkgCompilerOptions.GetInheritedCompilerOptions(var OptionsList: TList
);
procedure TPkgCompilerOptions.GetInheritedCompilerOptions(
var OptionsList: TFPList);
begin
if LazPackage<>nil then
LazPackage.GetInheritedCompilerOptions(OptionsList);

80
packager/packagesystem.pas
View File

@ -87,8 +87,8 @@ type
FErrorMsg: string;
FFCLPackage: TLazPackage;
FIDEIntfPackage: TLazPackage;
FItems: TList; // unsorted list of TLazPackage
FLazarusBasePackages: TList;
FItems: TFPList; // unsorted list of TLazPackage
FLazarusBasePackages: TFPList;
FLCLPackage: TLazPackage;
FOnAddPackage: TPkgAddedEvent;
FOnBeginUpdate: TNotifyEvent;
@ -136,16 +136,16 @@ type
function FindAPackageWithName(const PkgName: string;
IgnorePackage: TLazPackage): TLazPackage;
function FindBrokenDependencyPath(APackage: TLazPackage;
FirstDependency: TPkgDependency): TList;
FirstDependency: TPkgDependency): TFPList;
function FindAllBrokenDependencies(APackage: TLazPackage;
FirstDependency: TPkgDependency): TList;
FirstDependency: TPkgDependency): TFPList;
function FindCircleDependencyPath(APackage: TLazPackage;
FirstDependency: TPkgDependency): TList;
FirstDependency: TPkgDependency): TFPList;
function FindUnsavedDependencyPath(APackage: TLazPackage;
FirstDependency: TPkgDependency): TList;
FirstDependency: TPkgDependency): TFPList;
function FindNotInstalledRegisterUnits(APackage: TLazPackage;
FirstDependency: TPkgDependency): TList;
function FindAutoInstallDependencyPath(ChildPackage: TLazPackage): TList;
FirstDependency: TPkgDependency): TFPList;
function FindAutoInstallDependencyPath(ChildPackage: TLazPackage): TFPList;
function FindAmbiguousUnits(APackage: TLazPackage;
FirstDependency: TPkgDependency;
var File1, File2: TPkgFile;
@ -177,14 +177,14 @@ type
function PackageNameExists(const PkgName: string;
IgnorePackage: TLazPackage): boolean;
procedure GetAllRequiredPackages(FirstDependency: TPkgDependency;
var List: TList);
var List: TFPList);
procedure GetConnectionsTree(FirstDependency: TPkgDependency;
var PkgList: TList; var Tree: TPkgPairTree);
var PkgList: TFPList; var Tree: TPkgPairTree);
function GetAutoCompilationOrder(APackage: TLazPackage;
FirstDependency: TPkgDependency;
Policies: TPackageUpdatePolicies): TList;
Policies: TPackageUpdatePolicies): TFPList;
function GetBrokenDependenciesWhenChangingPkgID(APackage: TLazPackage;
const NewName: string; NewVersion: TPkgVersion): TList;
const NewName: string; NewVersion: TPkgVersion): TFPList;
procedure CalculateTopologicalLevels;
procedure SortDependencyListTopologically(
var FirstDependency: TPkgDependency; TopLevelFirst: boolean);
@ -249,7 +249,7 @@ type
property LCLPackage: TLazPackage read FLCLPackage;
property SynEditPackage: TLazPackage read FSynEditPackage;
property IDEIntfPackage: TLazPackage read FIDEIntfPackage;
property LazarusBasePackages: TList read FLazarusBasePackages;
property LazarusBasePackages: TFPList read FLazarusBasePackages;
property DefaultPackage: TLazPackage read FDefaultPackage;
property OnAddPackage: TPkgAddedEvent read FOnAddPackage write FOnAddPackage;
property OnBeginUpdate: TNotifyEvent read FOnBeginUpdate write FOnBeginUpdate;
@ -390,8 +390,8 @@ constructor TLazPackageGraph.Create;
begin
OnGetAllRequiredPackages:=@GetAllRequiredPackages;
FTree:=TAVLTree.Create(@CompareLazPackageID);
FItems:=TList.Create;
FLazarusBasePackages:=TList.Create;
FItems:=TFPList.Create;
FLazarusBasePackages:=TFPList.Create;
end;
destructor TLazPackageGraph.Destroy;
@ -1300,11 +1300,11 @@ begin
end;
function TLazPackageGraph.FindBrokenDependencyPath(APackage: TLazPackage;
FirstDependency: TPkgDependency): TList;
FirstDependency: TPkgDependency): TFPList;
// returns the first broken dependency
// the first irems are TLazPackage, the last item is a TPkgDependency
procedure FindBroken(Dependency: TPkgDependency; var PathList: TList);
procedure FindBroken(Dependency: TPkgDependency; var PathList: TFPList);
var
RequiredPackage: TLazPackage;
begin
@ -1324,7 +1324,7 @@ function TLazPackageGraph.FindBrokenDependencyPath(APackage: TLazPackage;
end;
end else begin
// broken dependency found
PathList:=TList.Create;
PathList:=TFPList.Create;
PathList.Add(Dependency);
exit;
end;
@ -1346,10 +1346,10 @@ begin
end;
function TLazPackageGraph.FindAllBrokenDependencies(APackage: TLazPackage;
FirstDependency: TPkgDependency): TList;
FirstDependency: TPkgDependency): TFPList;
// returns the list of broken dependencies (TPkgDependency)
procedure FindBroken(Dependency: TPkgDependency; var DepList: TList);
procedure FindBroken(Dependency: TPkgDependency; var DepList: TFPList);
var
RequiredPackage: TLazPackage;
begin
@ -1365,7 +1365,7 @@ function TLazPackageGraph.FindAllBrokenDependencies(APackage: TLazPackage;
// broken dependency found
if (DepList=nil) or (DepList.IndexOf(Dependency)<0) then begin
if DepList=nil then
DepList:=TList.Create;
DepList:=TFPList.Create;
DepList.Add(Dependency);
end;
end;
@ -1385,9 +1385,9 @@ begin
end;
function TLazPackageGraph.FindCircleDependencyPath(APackage: TLazPackage;
FirstDependency: TPkgDependency): TList;
FirstDependency: TPkgDependency): TFPList;
procedure FindCircle(Dependency: TPkgDependency; var PathList: TList);
procedure FindCircle(Dependency: TPkgDependency; var PathList: TFPList);
var
RequiredPackage: TLazPackage;
begin
@ -1397,7 +1397,7 @@ function TLazPackageGraph.FindCircleDependencyPath(APackage: TLazPackage;
RequiredPackage:=Dependency.RequiredPackage;
if lpfCircle in RequiredPackage.Flags then begin
// circle detected
PathList:=TList.Create;
PathList:=TFPList.Create;
PathList.Add(RequiredPackage);
exit;
end;
@ -1438,9 +1438,9 @@ begin
end;
function TLazPackageGraph.FindUnsavedDependencyPath(APackage: TLazPackage;
FirstDependency: TPkgDependency): TList;
FirstDependency: TPkgDependency): TFPList;
procedure FindUnsaved(Dependency: TPkgDependency; var PathList: TList);
procedure FindUnsaved(Dependency: TPkgDependency; var PathList: TFPList);
var
RequiredPackage: TLazPackage;
begin
@ -1450,7 +1450,7 @@ function TLazPackageGraph.FindUnsavedDependencyPath(APackage: TLazPackage;
RequiredPackage:=Dependency.RequiredPackage;
if RequiredPackage.Modified then begin
// unsaved package detected
PathList:=TList.Create;
PathList:=TFPList.Create;
PathList.Add(RequiredPackage);
exit;
end;
@ -1483,12 +1483,12 @@ begin
end;
function TLazPackageGraph.FindNotInstalledRegisterUnits(
APackage: TLazPackage; FirstDependency: TPkgDependency): TList;
APackage: TLazPackage; FirstDependency: TPkgDependency): TFPList;
// returns the list of required units (TPkgFile) with a Register procedure,
// that are not installed in the IDE
procedure FindNotInstalledRegisterUnit(Dependency: TPkgDependency;
var UnitList: TList);
var UnitList: TFPList);
var
RequiredPackage: TLazPackage;
i: Integer;
@ -1506,7 +1506,7 @@ function TLazPackageGraph.FindNotInstalledRegisterUnits(
if APkgFile.HasRegisterProc then begin
// unit with register procedure -> add
if UnitList=nil then
UnitList:=TList.Create;
UnitList:=TFPList.Create;
UnitList.Add(APkgFile);
end;
end;
@ -1531,7 +1531,7 @@ begin
end;
function TLazPackageGraph.FindAutoInstallDependencyPath(
ChildPackage: TLazPackage): TList;
ChildPackage: TLazPackage): TFPList;
procedure FindAutoInstallParent(APackage: TLazPackage);
var
@ -1546,7 +1546,7 @@ function TLazPackageGraph.FindAutoInstallDependencyPath(
ParentPackage.Flags:=ParentPackage.Flags+[lpfVisited];
if ParentPackage.AutoInstall<>pitNope then begin
// auto install parent found
if Result=nil then Result:=TList.Create;
if Result=nil then Result:=TFPList.Create;
Result.Add(ParentPackage);
Result.Add(APackage);
exit;
@ -1652,7 +1652,7 @@ var
end;
var
PkgList: TList;
PkgList: TFPList;
ConnectionsTree: TPkgPairTree;
ANode: TAVLTreeNode;
Pair: TPkgPair;
@ -1758,7 +1758,7 @@ begin
end;
function TLazPackageGraph.GetAutoCompilationOrder(APackage: TLazPackage;
FirstDependency: TPkgDependency; Policies: TPackageUpdatePolicies): TList;
FirstDependency: TPkgDependency; Policies: TPackageUpdatePolicies): TFPList;
// Returns all required auto update packages, including indirect requirements.
// The packages will be in topological order, with the package that should be
// compiled first at the end.
@ -1776,7 +1776,7 @@ function TLazPackageGraph.GetAutoCompilationOrder(APackage: TLazPackage;
// add first all needed packages
GetTopologicalOrder(RequiredPackage.FirstRequiredDependency);
// then add this package
if Result=nil then Result:=TList.Create;
if Result=nil then Result:=TFPList.Create;
Result.Add(RequiredPackage);
end;
end;
@ -1911,11 +1911,11 @@ end;
function TLazPackageGraph.GetBrokenDependenciesWhenChangingPkgID(
APackage: TLazPackage; const NewName: string; NewVersion: TPkgVersion
): TList;
): TFPList;
var
Dependency: TPkgDependency;
begin
Result:=TList.Create;
Result:=TFPList.Create;
// find all dependencies, that will become incompatible
Dependency:=APackage.FirstUsedByDependency;
while Dependency<>nil do begin
@ -2459,7 +2459,7 @@ begin
end;
procedure TLazPackageGraph.GetAllRequiredPackages(
FirstDependency: TPkgDependency; var List: TList);
FirstDependency: TPkgDependency; var List: TFPList);
// returns packages in topological order, beginning with the top level package
procedure GetTopologicalOrder(CurDependency: TPkgDependency);
@ -2475,7 +2475,7 @@ procedure TLazPackageGraph.GetAllRequiredPackages(
RequiredPackage.Flags:=RequiredPackage.Flags+[lpfVisited];
GetTopologicalOrder(RequiredPackage.FirstRequiredDependency);
// add package to list
if List=nil then List:=TList.Create;
if List=nil then List:=TFPList.Create;
List.Add(RequiredPackage);
end;
end;
@ -2504,7 +2504,7 @@ begin
end;
procedure TLazPackageGraph.GetConnectionsTree(FirstDependency: TPkgDependency;
var PkgList: TList; var Tree: TPkgPairTree);
var PkgList: TFPList; var Tree: TPkgPairTree);
procedure AddConnection(Pkg1, Pkg2: TLazPackage);
begin

4
packager/pkggraphexplorer.pas
View File

@ -113,7 +113,7 @@ type
procedure SelectPackage(Pkg: TLazPackage);
procedure OpenDependencyOwner(DependencyOwner: TObject);
function FindMainNodeWithText(const s: string): TTreeNode;
procedure ShowPath(PathList: TList);
procedure ShowPath(PathList: TFPList);
public
property OnOpenPackage: TOnOpenPackage read FOnOpenPackage write FOnOpenPackage;
property OnOpenProject: TOnOpenProject read FOnOpenProject write FOnOpenProject;
@ -582,7 +582,7 @@ begin
while (Result<>nil) and (Result.Text<>s) do Result:=Result.GetNextSibling;
end;
procedure TPkgGraphExplorerDlg.ShowPath(PathList: TList);
procedure TPkgGraphExplorerDlg.ShowPath(PathList: TFPList);
var
AnObject: TObject;
CurNode, LastNode: TTreeNode;

321
packager/pkgmanager.pas
View File

@ -58,7 +58,7 @@ uses
ComponentReg, UComponentManMain, PackageEditor, AddToPackageDlg, PackageDefs,
PackageLinks, PackageSystem, OpenInstalledPkgDlg, PkgGraphExplorer,
BrokenDependenciesDlg, CompilerOptions, ExtToolEditDlg,
TransferMacros, MsgView, BuildLazDialog, NewDialog,
TransferMacros, MsgView, BuildLazDialog, NewDialog, IDEDialogs,
ProjectInspector, ComponentPalette, UnitEditor, AddFileToAPackageDlg,
LazarusPackageIntf, PublishProjectDlg, InstallPkgSetDlg,
// bosses
@ -157,7 +157,7 @@ type
var Directory: string);
procedure GetWritablePkgOutputDirectory(APackage: TLazPackage;
var AnOutDirectory: string);
procedure OnCheckInstallPackageList(PkgIDList: TList; var Ok: boolean);
procedure OnCheckInstallPackageList(PkgIDList: TFPList; var Ok: boolean);
function LoadDependencyList(FirstDependency: TPkgDependency): TModalResult;
procedure OnOpenPackageForCurrentSrcEditFile(Sender: TObject);
private
@ -225,9 +225,9 @@ type
function GetMissingDependenciesForUnit(const UnitFilename: string;
ComponentClassnames: TStrings;
var List: TObjectArray): TModalResult;
function GetOwnersOfUnit(const UnitFilename: string): TList; override;
procedure ExtendOwnerListWithUsedByOwners(OwnerList: TList); override;
function GetSourceFilesOfOwners(OwnerList: TList): TStrings; override;
function GetOwnersOfUnit(const UnitFilename: string): TFPList; override;
procedure ExtendOwnerListWithUsedByOwners(OwnerList: TFPList); override;
function GetSourceFilesOfOwners(OwnerList: TFPList): TStrings; override;
function GetPackageOfCurrentSourceEditor: TPkgFile;
function DoOpenPkgFile(PkgFile: TPkgFile): TModalResult;
function FindVirtualUnitSource(PkgFile: TPkgFile): string;
@ -238,8 +238,8 @@ type
// package graph
function AddPackageToGraph(APackage: TLazPackage; Replace: boolean): TModalResult;
function DoShowPackageGraph: TModalResult;
procedure DoShowPackageGraphPathList(PathList: TList); override;
function ShowBrokenDependenciesReport(Dependencies: TList): TModalResult;
procedure DoShowPackageGraphPathList(PathList: TFPList); override;
function ShowBrokenDependenciesReport(Dependencies: TFPList): TModalResult;
procedure RebuildDefineTemplates; override;
// project
@ -312,7 +312,7 @@ type
TLazPackageDescriptors = class(TPackageDescriptors)
private
fDestroying: boolean;
fItems: TList; // list of TProjectDescriptor
fItems: TFPList; // list of TProjectDescriptor
protected
function GetItems(Index: integer): TPackageDescriptor; override;
public
@ -425,12 +425,12 @@ procedure TPkgManager.MainIDEitmPkgEditInstallPkgsClick(Sender: TObject);
var
RebuildIDE: Boolean;
PkgIDList: TList;
PkgIDList: TFPList;
NewFirstAutoInstallDependency: TPkgDependency;
BuildIDEFlags: TBuildLazarusFlags;
ok: boolean;
Report: String;
PkgList: TList;
PkgList: TFPList;
RequiredPackage: TLazPackage;
i: Integer;
CurDependency: TPkgDependency;
@ -458,9 +458,9 @@ begin
// which will be newly installed
Report:=CreateChangeReport(FirstAutoInstallDependency,
NewFirstAutoInstallDependency);
if MessageDlg('Confirm new package set for the IDE',
if IDEMessageDialog('Confirm new package set for the IDE',
'This will happen:'#13#13
+Report+#13'Continue?',mtConfirmation,[mbYes,mbNo],0)<>mrYes then exit;
+Report+#13'Continue?',mtConfirmation,[mbYes,mbNo])<>mrYes then exit;
// try to commit changes -> replace install list
PackageGraph.BeginUpdate(true);
@ -589,11 +589,11 @@ begin
debugln('TPkgManager.GetWritablePkgOutputDirectory APackage=',APackage.IDAsString,' AnOutDirectory="',AnOutDirectory,'"');
end;
procedure TPkgManager.OnCheckInstallPackageList(PkgIDList: TList;
procedure TPkgManager.OnCheckInstallPackageList(PkgIDList: TFPList;
var Ok: boolean);
var
NewFirstAutoInstallDependency: TPkgDependency;
PkgList: TList;
PkgList: TFPList;
i: Integer;
APackage: TLazPackage;
begin
@ -613,10 +613,10 @@ begin
if (APackage.PackageType=lptRunTime)
and (APackage.FirstUsedByDependency=nil) then begin
// this is a runtime only package, not needed by any other package
if MessageDlg(lisPkgMangPackageIsNoDesigntimePackage,
if IDEMessageDialog(lisPkgMangPackageIsNoDesigntimePackage,
Format(lisPkgMangThePackageIsARuntimeOnlyPackageRuntimeOnlyPackages, [
APackage.IDAsString, #13]),
mtWarning,[mbIgnore,mbCancel],0)<>mrIgnore
mtWarning,[mbIgnore,mbCancel])<>mrIgnore
then
exit;
end;
@ -650,9 +650,9 @@ begin
while CurDependency<>nil do begin
OpenResult:=PackageGraph.OpenDependency(CurDependency);
if OpenResult<>lprSuccess then begin
MessageDlg('Error',
IDEMessageDialog('Error',
'Unable to load package "'+CurDependency.AsString+'"',
mtError,[mbCancel],0);
mtError,[mbCancel]);
exit;
end;
CurDependency:=CurDependency.NextRequiresDependency;
@ -689,9 +689,9 @@ begin
PkgFile:=PackageGraph.FindFileInAllPackages(Filename,false,true,
not ActiveUnitInfo.IsPartOfProject);
if PkgFile=nil then begin
MessageDlg(lisProjAddPackageNotFound,
IDEMessageDialog(lisProjAddPackageNotFound,
lisPkgThisFileIsNotInAnyLoadedPackage, mtInformation,
[mbCancel],0);
[mbCancel]);
exit;
end;
DoOpenPackageFile(PkgFile.LazPackage.Filename,[pofAddToRecent])
@ -1000,7 +1000,7 @@ var
ConflictPkg: TLazPackage;
PkgFile: TPkgFile;
LowerFilename: String;
BrokenDependencies: TList;
BrokenDependencies: TFPList;
RenameDependencies: Boolean;
OldPkgName: String;
@ -1056,19 +1056,19 @@ begin
// append extension
NewFileName:=NewFileName+'.lpk';
end else if ExtractFileExt(NewFilename)<>'.lpk' then begin
Result:=MessageDlg(lisPkgMangInvalidPackageFileExtension,
Result:=IDEMessageDialog(lisPkgMangInvalidPackageFileExtension,
lisPkgMangPackagesMustHaveTheExtensionLpk,
mtInformation,[mbRetry,mbAbort],0);
mtInformation,[mbRetry,mbAbort]);
if Result=mrAbort then exit;
continue; // try again
end;
// check filename
if (NewPkgName='') or (not IsValidIdent(NewPkgName)) then begin
Result:=MessageDlg(lisPkgMangInvalidPackageName,
Result:=IDEMessageDialog(lisPkgMangInvalidPackageName,
Format(lisPkgMangThePackageNameIsNotAValidPackageNamePleaseChooseAn, [
'"', NewPkgName, '"', #13]),
mtInformation,[mbRetry,mbAbort],0);
mtInformation,[mbRetry,mbAbort]);
if Result=mrAbort then exit;
continue; // try again
end;
@ -1080,10 +1080,10 @@ begin
LowerFilename:=ExtractFilePath(NewFilename)+lowercase(ExtractFileName(NewFilename));
if EnvironmentOptions.CharcaseFileAction = ccfaAsk then
begin
if MessageDlg(lisPkgMangRenameFileLowercase,
if IDEMessageDialog(lisPkgMangRenameFileLowercase,
Format(lisPkgMangShouldTheFileRenamedLowercaseTo, [#13, '"',
LowerFilename, '"']),
mtConfirmation,[mbYes,mbNo],0)=mrYes
mtConfirmation,[mbYes,mbNo])=mrYes
then
NewFileName:=LowerFilename;
end
@ -1096,21 +1096,21 @@ begin
// check package name conflict
ConflictPkg:=PackageGraph.FindAPackageWithName(NewPkgName,APackage);
if ConflictPkg<>nil then begin
Result:=MessageDlg(lisPkgMangPackageNameAlreadyExists,
Result:=IDEMessageDialog(lisPkgMangPackageNameAlreadyExists,
Format(lisPkgMangThereIsAlreadyAnotherPackageWithTheName, ['"',
NewPkgName, '"', #13, '"', ConflictPkg.IDAsString, '"', #13, '"',
ConflictPkg.Filename, '"']),
mtInformation,[mbRetry,mbAbort,mbIgnore],0);
mtInformation,[mbRetry,mbAbort,mbIgnore]);
if Result=mrAbort then exit;
if Result<>mrIgnore then continue; // try again
end;
// check file name conflict with project
if Project1.ProjectUnitWithFilename(NewFilename)<>nil then begin
Result:=MessageDlg(lisPkgMangFilenameIsUsedByProject,
Result:=IDEMessageDialog(lisPkgMangFilenameIsUsedByProject,
Format(lisPkgMangTheFileNameIsPartOfTheCurrentProject, ['"',
NewFilename, '"', #13]),
mtInformation,[mbRetry,mbAbort],0);
mtInformation,[mbRetry,mbAbort]);
if Result=mrAbort then exit;
continue; // try again
end;
@ -1118,11 +1118,11 @@ begin
// check file name conflicts with files in other packages
PkgFile:=PackageGraph.FindFileInAllPackages(NewFilename,true,true,false);
if PkgFile<>nil then begin
Result:=MessageDlg(lisPkgMangFilenameIsUsedByOtherPackage,
Result:=IDEMessageDialog(lisPkgMangFilenameIsUsedByOtherPackage,
Format(lisPkgMangTheFileNameIsUsedByThePackageInFile, ['"',
NewFilename, '"', #13, '"', PkgFile.LazPackage.IDAsString, '"',
#13, '"', PkgFile.LazPackage.Filename, '"']),
mtWarning,[mbRetry,mbAbort],0);
mtWarning,[mbRetry,mbAbort]);
if Result=mrAbort then exit;
continue; // try again
end;
@ -1146,9 +1146,9 @@ begin
// check existing file
if (CompareFilenames(NewFileName,OldPkgFilename)<>0)
and FileExists(NewFileName) then begin
Result:=MessageDlg(lisPkgMangReplaceFile,
Result:=IDEMessageDialog(lisPkgMangReplaceFile,
Format(lisPkgMangReplaceExistingFile, ['"', NewFilename, '"']),
mtConfirmation,[mbOk,mbCancel],0);
mtConfirmation,[mbOk,mbCancel]);
if Result<>mrOk then exit;
end;
@ -1174,17 +1174,17 @@ begin
// clean up old package file to reduce ambiguousities
if FileExists(OldPkgFilename)
and (CompareFilenames(OldPkgFilename,NewFilename)<>0) then begin
if MessageDlg(lisPkgMangDeleteOldPackageFile,
if IDEMessageDialog(lisPkgMangDeleteOldPackageFile,
Format(lisPkgMangDeleteOldPackageFile2, ['"', OldPkgFilename, '"']),
mtConfirmation,[mbOk,mbCancel],0)=mrOk
mtConfirmation,[mbOk,mbCancel])=mrOk
then begin
if DeleteFile(OldPkgFilename) then begin
RemoveFromRecentList(OldPkgFilename,
EnvironmentOptions.RecentPackageFiles);
end else begin
MessageDlg(lisPkgMangDeleteFailed,
IDEMessageDialog(lisPkgMangDeleteFailed,
Format(lisPkgMangUnableToDeleteFile, ['"', OldPkgFilename, '"']),
mtError, [mbOk], 0);
mtError, [mbOk]);
end;
end;
end;
@ -1359,10 +1359,10 @@ begin
// compile package
Result:=LazarusIDE.RunExternalTool(FPCMakeTool);
if Result<>mrOk then begin
Result:=MessageDlg('fpcmake failed',
Result:=IDEMessageDialog('fpcmake failed',
'Calling '+FPCMakeTool.Filename+' to create Makefile from '
+MakefileFPCFilename+' failed.',
mtError,[mbCancel],0);
mtError,[mbCancel]);
exit;
end;
finally
@ -1377,7 +1377,7 @@ function TPkgManager.CompileRequiredPackages(APackage: TLazPackage;
FirstDependency: TPkgDependency; Globals: TGlobalCompilerOptions;
Policies: TPackageUpdatePolicies): TModalResult;
var
AutoPackages: TList;
AutoPackages: TFPList;
i: Integer;
begin
{$IFDEF VerbosePkgCompile}
@ -1409,7 +1409,7 @@ end;
function TPkgManager.CheckPackageGraphForCompilation(APackage: TLazPackage;
FirstDependency: TPkgDependency; const Directory: string): TModalResult;
var
PathList: TList;
PathList: TFPList;
Dependency: TPkgDependency;
PkgFile1,PkgFile2: TPkgFile;
ConflictPkg: TLazPackage;
@ -1424,9 +1424,9 @@ begin
PathList:=PackageGraph.FindUnsavedDependencyPath(APackage,FirstDependency);
if PathList<>nil then begin
DoShowPackageGraphPathList(PathList);
Result:=MessageDlg(lisPkgMangUnsavedPackage,
Result:=IDEMessageDialog(lisPkgMangUnsavedPackage,
lisPkgMangThereIsAnUnsavedPackageInTheRequiredPackages,
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
@ -1439,18 +1439,18 @@ begin
// check if project
if Dependency.Owner is TProject then begin
MainIDE.DoShowProjectInspector;
Result:=MessageDlg(lisPkgMangBrokenDependency,
Result:=IDEMessageDialog(lisPkgMangBrokenDependency,
Format(lisPkgMangTheProjectRequiresThePackageButItWasNotFound, [
'"', Dependency.AsString, '"', #13]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
end;
end;
DoShowPackageGraphPathList(PathList);
Result:=MessageDlg(lisPkgMangBrokenDependency,
Result:=IDEMessageDialog(lisPkgMangBrokenDependency,
lisPkgMangARequiredPackagesWasNotFound,
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
@ -1458,9 +1458,9 @@ begin
PathList:=PackageGraph.FindCircleDependencyPath(APackage,FirstDependency);
if PathList<>nil then begin
DoShowPackageGraphPathList(PathList);
Result:=MessageDlg(lisPkgMangCircleInPackageDependencies,
Result:=IDEMessageDialog(lisPkgMangCircleInPackageDependencies,
lisPkgMangThereIsACircleInTheRequiredPackages,
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
@ -1480,13 +1480,13 @@ begin
end else
s:='Internal inconsistency FindAmbiguousUnits: '
+'Please report this bug and how you got here.'#13;
Result:=MessageDlg(lisPkgMangAmbiguousUnitsFound, Format(
Result:=IDEMessageDialog(lisPkgMangAmbiguousUnitsFound, Format(
lisPkgMangBothPackagesAreConnectedThisMeansEitherOnePackageU, [s]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
// check for ambiguous units between packages
// check for ambiguous units between packages and FPC units
if PackageGraph.FindFPCConflictUnit(APackage,FirstDependency,Directory,
@PackageGraphFindFPCUnit,PkgFile1,ConflictPkg)
then begin
@ -1499,8 +1499,8 @@ begin
end else
s:='Internal inconsistency FindFPCConflictUnits: '
+'Please report this bug and how you got here.'#13;
Result:=MessageDlg(lisPkgMangAmbiguousUnitsFound, s,
mtError,[mbCancel,mbAbort],0);
Result:=IDEMessageDialog(lisPkgMangAmbiguousUnitsFound, s,
mtError,[mbCancel,mbAbort]);
exit;
end;
@ -1541,10 +1541,10 @@ begin
APackage.Flags:=APackage.Flags+[lpfStateFileLoaded];
except
on E: Exception do begin
Result:=MessageDlg(lisPkgMangErrorWritingFile,
Result:=IDEMessageDialog(lisPkgMangErrorWritingFile,
Format(lisPkgMangUnableToWriteStateFileOfPackageError, ['"', StateFile,
'"', #13, APackage.IDAsString, #13, E.Message]),
mtError,[mbAbort,mbCancel],0);
mtError,[mbAbort,mbCancel]);
exit;
end;
end;
@ -1588,10 +1588,10 @@ begin
if IgnoreErrors then begin
Result:=mrOk;
end else begin
Result:=MessageDlg(lisPkgMangErrorReadingFile,
Result:=IDEMessageDialog(lisPkgMangErrorReadingFile,
Format(lisPkgMangUnableToReadStateFileOfPackageError, ['"',
StateFile, '"', #13, APackage.IDAsString, #13, E.Message]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
end;
exit;
end;
@ -1620,29 +1620,29 @@ begin
// create the output directory
if not ForceDirectory(OutputDir) then begin
Result:=MessageDlg(lisPkgMangUnableToCreateDirectory,
Result:=IDEMessageDialog(lisPkgMangUnableToCreateDirectory,
Format(lisPkgMangUnableToCreateOutputDirectoryForPackage, ['"',
OutputDir, '"', #13, APackage.IDAsString]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
// delete old Compile State file
if FileExists(StateFile) and not DeleteFile(StateFile) then begin
Result:=MessageDlg(lisPkgMangUnableToDeleteFilename,
Result:=IDEMessageDialog(lisPkgMangUnableToDeleteFilename,
Format(lisPkgMangUnableToDeleteOldStateFileForPackage, ['"', StateFile,
'"', #13, APackage.IDAsString]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
APackage.Flags:=APackage.Flags-[lpfStateFileLoaded];
// create the package src directory
if not ForceDirectory(PkgSrcDir) then begin
Result:=MessageDlg(lisPkgMangUnableToCreateDirectory,
Result:=IDEMessageDialog(lisPkgMangUnableToCreateDirectory,
Format(lisPkgMangUnableToCreatePackageSourceDirectoryForPackage, ['"',
PkgSrcDir, '"', #13, APackage.IDAsString]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
@ -1838,10 +1838,10 @@ var
SearchFlags);
if (AmbiguousFilename='') then exit;
if not YesToAll then
Result:=MessageDlg(lisAmbiguousUnitFound,
Result:=IDEMessageDialog(lisAmbiguousUnitFound,
Format(lisTheFileWasFoundInOneOfTheSourceDirectoriesOfThePac, ['"',
AmbiguousFilename, '"', #13, APackage.IDAsString, #13, #13]),
mtWarning,[mbYes,mbYesToAll,mbNo,mbAbort],0)
mtWarning,[mbYes,mbYesToAll,mbNo,mbAbort])
else
Result:=mrYesToAll;
if Result=mrNo then
@ -1849,8 +1849,8 @@ var
if Result in [mrYes,mrYesToAll] then begin
YesToAll:=Result=mrYesToAll;
if (not DeleteFile(AmbiguousFilename))
and (MessageDlg(lisPkgMangDeleteFailed, Format(lisDeletingOfFileFailed,
['"', AmbiguousFilename, '"']), mtError, [mbIgnore, mbCancel], 0)
and (IDEMessageDialog(lisPkgMangDeleteFailed, Format(lisDeletingOfFileFailed,
['"', AmbiguousFilename, '"']), mtError, [mbIgnore, mbCancel])
<>mrIgnore) then
begin
Result:=mrCancel;
@ -2047,7 +2047,7 @@ end;
procedure TPkgManager.LoadStaticCustomPackages;
var
StaticPackages: TList;
StaticPackages: TFPList;
StaticPackage: PRegisteredPackage;
i: Integer;
APackage: TLazPackage;
@ -2127,9 +2127,9 @@ begin
Dependency.PackageName:=PackageName;
Dependency.AddToList(FirstAutoInstallDependency,pdlRequires);
if PackageGraph.OpenDependency(Dependency)<>lprSuccess then begin
MessageDlg(lisPkgMangUnableToLoadPackage,
IDEMessageDialog(lisPkgMangUnableToLoadPackage,
Format(lisPkgMangUnableToOpenThePackage, ['"', PackageName, '"', #13]),
mtWarning,[mbOk],0);
mtWarning,[mbOk]);
continue;
end;
if not Dependency.RequiredPackage.Missing then
@ -2389,10 +2389,10 @@ var
begin
// check Package Name
if (APackage.Name='') or (not IsValidIdent(APackage.Name)) then begin
Result:=MessageDlg(lisPkgMangInvalidPackageName2,
Result:=IDEMessageDialog(lisPkgMangInvalidPackageName2,
Format(lisPkgMangThePackageNameOfTheFileIsInvalid, ['"', APackage.Name,
'"', #13, '"', APackage.Filename, '"']),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
@ -2400,20 +2400,20 @@ begin
ConflictPkg:=PackageGraph.FindAPackageWithName(APackage.Name,nil);
if ConflictPkg<>nil then begin
if not PackageGraph.PackageCanBeReplaced(ConflictPkg,APackage) then begin
Result:=MessageDlg(lisPkgMangPackageConflicts,
Result:=IDEMessageDialog(lisPkgMangPackageConflicts,
Format(lisPkgMangThereIsAlreadyAPackageLoadedFromFile, ['"',
ConflictPkg.IDAsString, '"', #13, '"', ConflictPkg.Filename, '"',
#13, #13]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
if ConflictPkg.Modified and (not ConflictPkg.ReadOnly) then begin
Result:=MessageDlg(lisPkgMangSavePackage,
Result:=IDEMessageDialog(lisPkgMangSavePackage,
Format(lisPkgMangLoadingPackageWillReplacePackage, [
APackage.IDAsString, ConflictPkg.IDAsString, #13,
ConflictPkg.Filename, #13, #13, #13, ConflictPkg.Filename]),
mtConfirmation,[mbYes,mbNo,mbCancel,mbAbort],0);
mtConfirmation,[mbYes,mbNo,mbCancel,mbAbort]);
if Result=mrNo then Result:=mrOk;
if Result=mrYes then begin
Result:=DoSavePackage(ConflictPkg,[]);
@ -2437,7 +2437,7 @@ end;
function TPkgManager.OpenProjectDependencies(AProject: TProject;
ReportMissing: boolean): TModalResult;
var
BrokenDependencies: TList;
BrokenDependencies: TFPList;
begin
PackageGraph.OpenRequiredDependencyList(AProject.FirstRequiredDependency);
if ReportMissing then begin
@ -2508,7 +2508,7 @@ end;
function TPkgManager.CheckProjectHasInstalledPackages(AProject: TProject
): TModalResult;
var
MissingUnits: TList;
MissingUnits: TFPList;
i: Integer;
PkgFile: TPkgFile;
Msg: String;
@ -2524,8 +2524,8 @@ begin
Msg:=Msg+' unit '+PkgFile.UnitName
+' in package '+PkgFile.LazPackage.IDAsString+#13;
end;
Result:=MessageDlg(lisPackageNeedsInstallation,
Msg,mtWarning,[mbIgnore,mbCancel],0);
Result:=IDEMessageDialog(lisPackageNeedsInstallation,
Msg,mtWarning,[mbIgnore,mbCancel]);
if Result<>mrIgnore then
AProject.AutoOpenDesignerFormsDisabled:=true;
MissingUnits.Free;
@ -2584,9 +2584,9 @@ begin
// check file extension
if CompareFileExt(AFilename,'.lpk',false)<>0 then begin
Result:=MessageDlg(lisPkgMangInvalidFileExtension,
Result:=IDEMessageDialog(lisPkgMangInvalidFileExtension,
Format(lisPkgMangTheFileIsNotALazarusPackage, ['"', AFilename, '"']),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
RemoveFromRecentList(AFilename,EnvironmentOptions.RecentPackageFiles);
SetRecentPackagesMenu;
exit;
@ -2596,10 +2596,10 @@ begin
AlternativePkgName:=ExtractFileNameOnly(AFilename);
if (AlternativePkgName='') or (not IsValidIdent(AlternativePkgName)) then
begin
Result:=MessageDlg(lisPkgMangInvalidPackageFilename,
Result:=IDEMessageDialog(lisPkgMangInvalidPackageFilename,
Format(lisPkgMangThePackageFileNameInIsNotAValidLazarusPackageName, ['"',
AlternativePkgName, '"', #13, '"', AFilename, '"']),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
RemoveFromRecentList(AFilename,EnvironmentOptions.RecentPackageFiles);
SetRecentPackagesMenu;
exit;
@ -2618,9 +2618,9 @@ begin
// package not yet loaded
if not FileExists(AFilename) then begin
MessageDlg(lisFileNotFound,
IDEMessageDialog(lisFileNotFound,
Format(lisPkgMangFileNotFound, ['"', AFilename, '"']),
mtError,[mbCancel],0);
mtError,[mbCancel]);
RemoveFromRecentList(AFilename,EnvironmentOptions.RecentPackageFiles);
SetRecentPackagesMenu;
Result:=mrCancel;
@ -2643,10 +2643,10 @@ begin
end;
except
on E: Exception do begin
Result:=MessageDlg(lisPkgMangErrorReadingPackage,
Result:=IDEMessageDialog(lisPkgMangErrorReadingPackage,
Format(lisPkgUnableToReadPackageFileError, ['"', AFilename, '"',
#13, E.Message]),
mtError,[mbAbort,mbCancel],0);
mtError,[mbAbort,mbCancel]);
exit;
end;
end;
@ -2656,11 +2656,11 @@ begin
// check if package name and file name correspond
if (SysUtils.CompareText(AlternativePkgName,APackage.Name)<>0) then begin
Result:=MessageDlg(lisPkgMangFilenameDiffersFromPackagename,
Result:=IDEMessageDialog(lisPkgMangFilenameDiffersFromPackagename,
Format(lisPkgMangTheFilenameDoesNotCorrespondToThePackage, ['"',
ExtractFileName(AFilename), '"', '"', APackage.Name, '"', #13, '"',
AlternativePkgName, '"']),
mtConfirmation,[mbYes,mbCancel,mbAbort],0);
mtConfirmation,[mbYes,mbCancel,mbAbort]);
if Result<>mrYes then exit;
APackage.Name:=AlternativePkgName;
end;
@ -2699,10 +2699,10 @@ begin
// ask user if package should be saved
if psfAskBeforeSaving in Flags then begin
Result:=MessageDlg(lisPkgMangSavePackage2,
Result:=IDEMessageDialog(lisPkgMangSavePackage2,
Format(lisPkgMangPackageChangedSave, ['"', APackage.IDAsString,
'"']),
mtConfirmation,[mbYes,mbNo,mbAbort],0);
mtConfirmation,[mbYes,mbNo,mbAbort]);
if (Result=mrNo) then Result:=mrIgnore;
if Result<>mrYes then exit;
end;
@ -2747,11 +2747,11 @@ begin
end;
except
on E: Exception do begin
Result:=MessageDlg(lisPkgMangErrorWritingPackage,
Result:=IDEMessageDialog(lisPkgMangErrorWritingPackage,
Format(lisPkgMangUnableToWritePackageToFileError, ['"',
APackage.IDAsString, '"', #13, '"', APackage.Filename, '"', #13,
E.Message]),
mtError,[mbAbort,mbCancel],0);
mtError,[mbAbort,mbCancel]);
exit;
end;
end;
@ -2791,13 +2791,13 @@ begin
Result:=mrOk;
end;
procedure TPkgManager.DoShowPackageGraphPathList(PathList: TList);
procedure TPkgManager.DoShowPackageGraphPathList(PathList: TFPList);
begin
if DoShowPackageGraph<>mrOk then exit;
PackageGraphExplorer.ShowPath(PathList);
end;
function TPkgManager.ShowBrokenDependenciesReport(Dependencies: TList
function TPkgManager.ShowBrokenDependenciesReport(Dependencies: TFPList
): TModalResult;
var
Msg: String;
@ -2826,7 +2826,7 @@ begin
end;
end;
Result:=MessageDlg(lisMissingPackages, Msg, mtError, [mbOk], 0);
Result:=IDEMessageDialog(lisMissingPackages, Msg, mtError, [mbOk]);
end;
procedure TPkgManager.RebuildDefineTemplates;
@ -2988,10 +2988,10 @@ begin
CheckIfFileIsExecutable(CompilerFilename);
except
on e: Exception do begin
Result:=MessageDlg(lisPkgManginvalidCompilerFilename,
Result:=IDEMessageDialog(lisPkgManginvalidCompilerFilename,
Format(lisPkgMangTheCompilerFileForPackageIsNotAValidExecutable, [
APackage.IDAsString, #13, E.Message]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
end;
@ -3047,11 +3047,11 @@ begin
// package was tried to install, but failed
// -> ask user if the package should be removed from the installation
// list
if MessageDlg(lisInstallationFailed,
if IDEMessageDialog(lisInstallationFailed,
Format(
lisPkgMangThePackageFailedToCompileRemoveItFromTheInstallati, [
'"', APackage.IDAsString, '"', #13]), mtConfirmation,
[mbYes,mbIgnore],0)=mrYes then
[mbYes,mbIgnore])=mrYes then
begin
DoUninstallPackage(APackage,[puifDoNotConfirm,puifDoNotBuildIDE]);
end;
@ -3095,10 +3095,10 @@ begin
// check if package is ready for saving
OutputDir:=APackage.GetOutputDirectory;
if not DirPathExists(OutputDir) then begin
Result:=MessageDlg(lisEnvOptDlgDirectoryNotFound,
Result:=IDEMessageDialog(lisEnvOptDlgDirectoryNotFound,
Format(lisPkgMangPackageHasNoValidOutputDirectory, ['"',
APackage.IDAsString, '"', #13, '"', OutputDir, '"']),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
@ -3257,10 +3257,10 @@ begin
NewPkgFile:=PackageGraph.FindFileInAllPackages(NewFilename,false,true,false);
if (NewPkgFile<>nil) and (OldPackage<>NewPkgFile.LazPackage) then exit;
Result:=MessageDlg(lisPkgMangRenameFileInPackage,
Result:=IDEMessageDialog(lisPkgMangRenameFileInPackage,
Format(lisPkgMangThePackageOwnsTheFileShouldTheFileBeRenamed, [
OldPackage.IDAsString, #13, '"', OldFilename, '"', #13]),
mtConfirmation,[mbYes,mbNo,mbAbort],0);
mtConfirmation,[mbYes,mbNo,mbAbort]);
if Result=mrNo then begin
Result:=mrOk;
exit;
@ -3285,7 +3285,7 @@ function TPkgManager.FindIncludeFileInProjectDependencies(Project1: TProject;
var
APackage: TLazPackage;
IncPath: String;
PkgList: Tlist;
PkgList: TFPList;
i: Integer;
begin
Result:='';
@ -3313,7 +3313,7 @@ function TPkgManager.AddUnitDependenciesForComponentClasses(
var
UnitBuf: TCodeBuffer;
UnitNames: TStringList;
Packages: TList;
Packages: TFPList;
MissingDependencies: TObjectArray;
function LoadAndParseUnitBuf: TModalResult;
@ -3325,9 +3325,9 @@ var
end;
UnitBuf:=CodeToolBoss.LoadFile(UnitFilename,false,false);
if UnitBuf=nil then begin
Result:=MessageDlg('Error loading file',
Result:=IDEMessageDialog('Error loading file',
'Loading '+UnitFilename+' failed.',
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
Result:=mrOk;
@ -3422,8 +3422,8 @@ var
Msg:=Msg+PackageAdditions;
end;
if Msg<>'' then begin
Result:=MessageDlg(lisConfirmChanges,
Msg,mtConfirmation,[mbOk,mbAbort],0);
Result:=IDEMessageDialog(lisConfirmChanges,
Msg,mtConfirmation,[mbOk,mbAbort]);
exit;
end;
Result:=mrOk;
@ -3469,7 +3469,7 @@ var
begin
Result:=mrCancel;
UnitNames:=TStringList.Create;
Packages:=TList.Create;
Packages:=TFPList.Create;
MissingDependencies:=nil;
try
@ -3511,7 +3511,7 @@ function TPkgManager.GetMissingDependenciesForUnit(
var List: TObjectArray): TModalResult;
// returns a list of packages needed to use the Component in the unit
var
UnitOwners: TList;
UnitOwners: TFPList;
UnitOwner: TObject;
FirstDependency: TPkgDependency;
CurClassID: Integer;
@ -3560,11 +3560,11 @@ begin
Result:=mrOk;
end;
function TPkgManager.GetOwnersOfUnit(const UnitFilename: string): TList;
function TPkgManager.GetOwnersOfUnit(const UnitFilename: string): TFPList;
var
PkgFile: TPkgFile;
begin
Result:=TList.Create;
Result:=TFPList.Create;
// check if unit is part of project
if Project1<>nil then begin
if Project1.UnitInfoWithFilename(UnitFilename,
@ -3580,13 +3580,13 @@ begin
FreeThenNil(Result);
end;
procedure TPkgManager.ExtendOwnerListWithUsedByOwners(OwnerList: TList);
procedure TPkgManager.ExtendOwnerListWithUsedByOwners(OwnerList: TFPList);
// use items (packages and projects) in OwnerList as leaves and create the
// list of all packages and projects using them.
// The result will be the topologically sorted list of projects and packages
// using the projects/packages in OwnerList, beginning with the top levels.
var
AddedNonPackages: TList;
AddedNonPackages: TFPList;
procedure AddUsedByOwners(ADependenyOwner: TObject);
var
@ -3612,20 +3612,20 @@ var
var
i: Integer;
OldOwnerList: TList;
OldOwnerList: TFPList;
begin
OldOwnerList:=TList.Create;
OldOwnerList:=TFPList.Create;
for i:=0 to OwnerList.Count-1 do
OldOwnerList.Add(OwnerList[i]);
OwnerList.Clear;
AddedNonPackages:=TList.Create;
AddedNonPackages:=TFPList.Create;
PackageGraph.MarkAllPackagesAsNotVisited;
for i:=0 to OldOwnerList.Count-1 do
AddUsedByOwners(TObject(OldOwnerList[i]));
OldOwnerList.Free;
end;
function TPkgManager.GetSourceFilesOfOwners(OwnerList: TList): TStrings;
function TPkgManager.GetSourceFilesOfOwners(OwnerList: TFPList): TStrings;
procedure AddFile(TheOwner: TObject; const Filename: string);
begin
@ -3746,28 +3746,28 @@ begin
// check if filename is absolute
if ActiveUnitInfo.IsVirtual or (not FileExists(Filename)) then begin
Result:=MessageDlg(lisPkgMangFileNotSaved,
Result:=IDEMessageDialog(lisPkgMangFileNotSaved,
lisPkgMangPleaseSaveTheFileBeforeAddingItToAPackage,
mtWarning,[mbCancel],0);
mtWarning,[mbCancel]);
exit;
end;
// check if file is part of project
if ActiveUnitInfo.IsPartOfProject then begin
Result:=MessageDlg(lisPkgMangFileIsInProject,
Result:=IDEMessageDialog(lisPkgMangFileIsInProject,
Format(lisPkgMangWarningTheFileBelongsToTheCurrentProject, ['"',
Filename, '"', #13])
,mtWarning,[mbIgnore,mbCancel,mbAbort],0);
,mtWarning,[mbIgnore,mbCancel,mbAbort]);
if Result<>mrIgnore then exit;
end;
// check if file is already in a package
PkgFile:=PackageGraph.FindFileInAllPackages(Filename,false,true,true);
if PkgFile<>nil then begin
Result:=MessageDlg(lisPkgMangFileIsAlreadyInPackage,
Result:=IDEMessageDialog(lisPkgMangFileIsAlreadyInPackage,
Format(lisPkgMangTheFileIsAlreadyInThePackage, ['"', Filename, '"', #13,
PkgFile.LazPackage.IDAsString]),
mtWarning,[mbIgnore,mbCancel,mbAbort],0);
mtWarning,[mbIgnore,mbCancel,mbAbort]);
if Result<>mrIgnore then exit;
end;
@ -3802,10 +3802,10 @@ begin
if not FileExistsCached(AFilename) then begin
if not APackage.IsVirtual then
AFilename:=CreateRelativePath(AFilename,APackage.Directory);
Result:=QuestionDlg(lisPkgMangPackageFileMissing,
Result:=IDEQuestionDialog(lisPkgMangPackageFileMissing,
Format(lisPkgMangTheFileOfPackageIsMissing, ['"', AFilename, '"',
#13, APackage.IDAsString]),
mtWarning,[mrIgnore,mrAbort],0);
mtWarning,[mrIgnore,mrAbort]);
if Result<>mrAbort then
Result:=mrOk;
// one warning is enough
@ -3814,11 +3814,10 @@ begin
end else begin
if not APackage.IsVirtual then begin
// an unsaved file
Result:=QuestionDlg(lisPkgMangPackageFileNotSaved,
Result:=IDEQuestionDialog(lisPkgMangPackageFileNotSaved,
Format(lisPkgMangTheFileOfPackageNeedsToBeSavedFirst, ['"',
AFilename, '"', #13, APackage.IDAsString]),
mtWarning, [mrIgnore, lisPkgMangIgnoreAndSavePackageNow, mrAbort], 0
);
mtWarning, [mrIgnore, lisPkgMangIgnoreAndSavePackageNow, mrAbort]);
if Result<>mrAbort then
Result:=mrOk;
end;
@ -3828,7 +3827,7 @@ end;
function TPkgManager.DoInstallPackage(APackage: TLazPackage): TModalResult;
var
PkgList: TList;
PkgList: TFPList;
function GetPkgListIndex(APackage: TLazPackage): integer;
begin
@ -3851,10 +3850,10 @@ begin
try
// check if package is designtime package
if APackage.PackageType=lptRunTime then begin
Result:=MessageDlg(lisPkgMangPackageIsNoDesigntimePackage,
Result:=IDEMessageDialog(lisPkgMangPackageIsNoDesigntimePackage,
Format(lisPkgMangThePackageIsARuntimeOnlyPackageRuntimeOnlyPackages, [
APackage.IDAsString, #13]),
mtError,[mbIgnore,mbAbort],0);
mtError,[mbIgnore,mbAbort]);
if Result<>mrIgnore then exit;
end;
@ -3871,7 +3870,7 @@ begin
// get all required packages, which will also be auto installed
APackage.GetAllRequiredPackages(PkgList);
if PkgList=nil then PkgList:=TList.Create;
if PkgList=nil then PkgList:=TFPList.Create;
// remove packages already marked for installation
for i:=PkgList.Count-1 downto 0 do begin
@ -3897,8 +3896,8 @@ begin
Msg:=Format(
lisPkgMangInstallingThePackageWillAutomaticallyInstallThePac2, [
APackage.IDAsString]);
Result:=MessageDlg(lisPkgMangAutomaticallyInstalledPackages,
Msg+#13+s,mtConfirmation,[mbOk,mbCancel,mbAbort],0);
Result:=IDEMessageDialog(lisPkgMangAutomaticallyInstalledPackages,
Msg+#13+s,mtConfirmation,[mbOk,mbCancel,mbAbort]);
if Result<>mrOk then exit;
end;
@ -3932,10 +3931,10 @@ begin
if Result<>mrOk then exit;
// ask user to rebuilt Lazarus now
Result:=MessageDlg(lisPkgMangRebuildLazarus,
Result:=IDEMessageDialog(lisPkgMangRebuildLazarus,
Format(lisPkgMangThePackageWasMarkedForInstallationCurrentlyLazarus, [
'"', APackage.IDAsString, '"', #13, #13, #13]),
mtConfirmation,[mbYes,mbNo],0);
mtConfirmation,[mbYes,mbNo]);
if Result=mrNo then begin
Result:=mrOk;
exit;
@ -3951,7 +3950,7 @@ end;
function TPkgManager.DoUninstallPackage(APackage: TLazPackage;
Flags: TPkgUninstallFlags): TModalResult;
var
DependencyPath: TList;
DependencyPath: TFPList;
ParentPackage: TLazPackage;
Dependency: TPkgDependency;
BuildIDEFlags: TBuildLazarusFlags;
@ -3963,18 +3962,18 @@ begin
if DependencyPath<>nil then begin
DoShowPackageGraphPathList(DependencyPath);
ParentPackage:=TLazPackage(DependencyPath[0]);
Result:=MessageDlg(lisPkgMangPackageIsRequired,
Result:=IDEMessageDialog(lisPkgMangPackageIsRequired,
Format(lisPkgMangThePackageIsRequiredByWhichIsMarkedForInstallation, [
APackage.IDAsString, ParentPackage.IDAsString, #13]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
// confirm uninstall package
if not (puifDoNotConfirm in Flags) then begin
Result:=MessageDlg(lisPkgMangUninstallPackage,
Result:=IDEMessageDialog(lisPkgMangUninstallPackage,
Format(lisPkgMangUninstallPackage2, [APackage.IDAsString]),
mtConfirmation,[mbYes,mbCancel,mbAbort],0);
mtConfirmation,[mbYes,mbCancel,mbAbort]);
if Result<>mrYes then exit;
end;
@ -4006,10 +4005,10 @@ begin
if not (puifDoNotBuildIDE in Flags) then begin
// ask user to rebuilt Lazarus now
Result:=MessageDlg(lisPkgMangRebuildLazarus,
Result:=IDEMessageDialog(lisPkgMangRebuildLazarus,
Format(lisPkgMangThePackageWasMarkedCurrentlyLazarus, ['"',
APackage.IDAsString, '"', #13, #13, #13]),
mtConfirmation,[mbYes,mbNo],0);
mtConfirmation,[mbYes,mbNo]);
if Result=mrNo then begin
Result:=mrOk;
exit;
@ -4031,13 +4030,15 @@ var
begin
Result:=mrCancel;
if APackage.IsVirtual then begin
MessageDlg(lisPkgMangThisIsAVirtualPackageItHasNoSourceYetPleaseSaveThe,
mtError, [mbCancel], 0);
IDEMessageDialog('Error',
lisPkgMangThisIsAVirtualPackageItHasNoSourceYetPleaseSaveThe,
mtError, [mbCancel]);
exit;
end;
Filename:=APackage.GetSrcFilename;
if (not FilenameIsAbsolute(Filename)) or (not FileExists(Filename)) then begin
MessageDlg(lisPkgMangPleaseSaveThePackageFirst, mtError, [mbCancel], 0);
IDEMessageDialog('Error',lisPkgMangPleaseSaveThePackageFirst, mtError,
[mbCancel]);
exit;
end;
Result:=MainIDE.DoOpenEditorFile(Filename,-1,[ofRegularFile]);
@ -4056,10 +4057,10 @@ begin
OldDependency:=Dependency;
Dependency:=Dependency.NextRequiresDependency;
if OldDependency.LoadPackageResult<>lprSuccess then begin
Result:=MessageDlg(lisProjAddPackageNotFound,
Result:=IDEMessageDialog(lisProjAddPackageNotFound,
Format(lisPkgMangThePackageIsMarkedForInstallationButCanNotBeFound, [
'"', OldDependency.AsString, '"', #13]),
mtError,[mbYes,mbNo,mbAbort],0);
mtError,[mbYes,mbNo,mbAbort]);
if Result=mrNo then Result:=mrCancel;
if Result<>mrYes then exit;
OldDependency.RemoveFromList(FirstAutoInstallDependency,pdlRequires);
@ -4116,10 +4117,10 @@ begin
TargetDir:=MiscellaneousOptions.BuildLazOpts.TargetDirectory;
IDEMacros.SubstituteMacros(TargetDir);
if not ForceDirectory(TargetDir) then begin
Result:=MessageDlg(lisPkgMangUnableToCreateDirectory,
Result:=IDEMessageDialog(lisPkgMangUnableToCreateDirectory,
Format(lisPkgMangUnableToCreateTargetDirectoryForLazarus, [#13, '"',
TargetDir, '"', #13]),
mtError,[mbCancel,mbAbort],0);
mtError,[mbCancel,mbAbort]);
exit;
end;
@ -4139,8 +4140,8 @@ function TPkgManager.DoGetIDEInstallPackageOptions(
end;
var
PkgList: TList;
AddOptionsList: TList;
PkgList: TFPList;
AddOptionsList: TFPList;
ConfigDir: String;
begin
Result:='';
@ -4314,7 +4315,7 @@ end;
constructor TLazPackageDescriptors.Create;
begin
PackageDescriptors:=Self;
FItems:=TList.Create;
FItems:=TFPList.Create;
end;
destructor TLazPackageDescriptors.Destroy;

2
packager/pkgoptionsdlg.pas
View File

@ -326,7 +326,7 @@ procedure TPackageOptionsDialog.OkButtonClick(Sender: TObject);
var
NewPackageType: TLazPackageType;
NewVersion: TPkgVersion;
BrokenDependencies: TList;
BrokenDependencies: TFPList;
RenameDependencies: Boolean;
MsgResult: TModalResult;
begin

4
packager/registration/lazaruspackageintf.pas
View File

@ -46,7 +46,7 @@ type
PRegisteredPackage = ^TRegisteredPackage;
var
RegisteredPackages: TList; // list of PRegisteredPackage
RegisteredPackages: TFPList; // list of PRegisteredPackage
RegisterUnitProc: TRegisterUnitProc;
procedure RegisterUnit(const TheUnitName: string; RegisterProc: TRegisterProc);
@ -66,7 +66,7 @@ procedure RegisterPackage(const ThePackageName: string;
var
NewRegisteredPackage: PRegisteredPackage;
begin
if RegisteredPackages=nil then RegisteredPackages:=TList.Create;
if RegisteredPackages=nil then RegisteredPackages:=TFPList.Create;
New(NewRegisteredPackage);
NewRegisteredPackage^.Name:=ThePackageName;
NewRegisteredPackage^.RegisterProc:=RegisterProc;