paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2026-01-06 17:00:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

Copy AVL_Tree from FPC trunk and replace classes in AvgLvlTree and in CodetoolsStructs with it.

Browse Source 
The unit in FPC packages will be used directly later.

git-svn-id: trunk@54524 -
This commit is contained in:
juha 2017-04-05 08:34:48 +00:00
parent e4b9cb055c
commit e800a738ad
147 changed files with 2883 additions and 3139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitattributes vendored
View File

@ -3007,6 +3007,7 @@ components/lazutils/laz2_xmlread.pas svneol=native#text/pascal
components/lazutils/laz2_xmlutils.pas svneol=native#text/pascal
components/lazutils/laz2_xmlwrite.pas svneol=native#text/pascal
components/lazutils/laz2_xpath.pas svneol=native#text/plain
components/lazutils/laz_avl_tree.pp svneol=native#text/pascal
components/lazutils/laz_dom.pas svneol=native#text/pascal
components/lazutils/laz_xmlcfg.pas svneol=native#text/pascal
components/lazutils/laz_xmlread.pas svneol=native#text/pascal

7
components/codetools/basiccodetools.pas
View File

@ -39,8 +39,11 @@ unit BasicCodeTools;
interface
uses
Classes, SysUtils, AVL_Tree, SourceLog, KeywordFuncLists, FileProcs,
LazFileUtils, LazUTF8, strutils;
Classes, SysUtils, strutils, Laz_AVL_Tree,
// LazUtils
LazFileUtils, LazUTF8,
// Codetools
SourceLog, KeywordFuncLists, FileProcs;
//----------------------------------------------------------------------------
{ These functions are used by the codetools }

5
components/codetools/cachecodetools.pas
View File

@ -30,9 +30,10 @@ unit CacheCodeTools;
interface
uses
Classes, SysUtils,
Classes, SysUtils, Laz_AVL_Tree,
// Codetools
FileProcs, CodeCache, KeywordFuncLists, CustomCodeTool,
BasicCodeTools, FindDeclarationTool, AVL_Tree;
BasicCodeTools, FindDeclarationTool;
type

16
components/codetools/ccodeparsertool.pas
View File

@ -111,12 +111,12 @@ uses
MemCheck,
{$ENDIF}
// RTL + FCL
Classes, SysUtils, AVL_Tree,
Classes, SysUtils, Laz_AVL_Tree,
// CodeTools
FileProcs, CodeToolsStructs, BasicCodeTools, KeywordFuncLists, LinkScanner,
CodeCache, CodeTree, NonPascalCodeTools,
FileProcs, BasicCodeTools, KeywordFuncLists, CodeCache, CodeTree,
NonPascalCodeTools, CodeToolsStructs,
// LazUtils
LazFileUtils;
LazFileUtils, AvgLvlTree;
type
TCCodeNodeDesc = word;
@ -352,7 +352,7 @@ type
LinkCount: integer;
Links: PCHFileLink;
LinksCapacity: integer;
Macros: TStringToStringTree;
Macros: TIdentStringToStringTree;
constructor Create;
destructor Destroy; override;
procedure Clear;
@ -493,7 +493,7 @@ end;
constructor TCHeaderFileMerger.Create;
begin
Macros:=TStringToStringTree.Create(true);
Macros:=TIdentStringToStringTree.Create(true);
end;
destructor TCHeaderFileMerger.Destroy;
@ -558,7 +558,7 @@ var
p: LongInt;
MacroValue: string;
MacroNode: TAVLTreeNode;
MacroItem: PStringToStringTreeItem;
MacroItem: PStringToStringItem;
Src: String;
BracketLvl: Integer;
begin
@ -592,7 +592,7 @@ var
MacroNode:=Macros.FindNodeWithIdentifierAsPrefix(StartP);
if MacroNode<>nil then begin
// macro found
MacroItem:=PStringToStringTreeItem(MacroNode.Data);
MacroItem:=PStringToStringItem(MacroNode.Data);
MacroValue:=MacroItem^.Value;
//debugln(['Append MacroName=',MacroItem^.Name,' Src=',GetIdentifier(@Src[AtomStart]),' Value=',dbgstr(MacroValue)]);
// write source in front of macro

5
components/codetools/changedeclarationtool.pas
View File

@ -31,8 +31,9 @@ unit ChangeDeclarationTool;
interface
uses
Classes, SysUtils, AVL_Tree, contnrs, CodeAtom, CodeCache,
FileProcs, CodeTree, ExtractProcTool, FindDeclarationTool,
Classes, SysUtils, Laz_AVL_Tree, contnrs,
// Codetools
CodeAtom, CodeCache, FileProcs, CodeTree, ExtractProcTool, FindDeclarationTool,
BasicCodeTools, KeywordFuncLists, LinkScanner, SourceChanger;
type

4
components/codetools/codeatom.pas
View File

@ -39,7 +39,9 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, FileProcs, AVL_Tree, KeywordFuncLists;
SysUtils,
// Codetools
FileProcs, KeywordFuncLists;
type
TCommonAtomFlag = (

4
components/codetools/codebeautifier.pas
View File

@ -109,8 +109,10 @@ interface
{$ENDIF}
uses
Classes, SysUtils, AVL_Tree,
Classes, SysUtils, Laz_AVL_Tree,
// Codetools
FileProcs, KeywordFuncLists, CodeCache, BasicCodeTools,
// LazUtils
LazUtilities;
type

19
components/codetools/codecache.pas
View File

@ -37,8 +37,11 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, SourceLog, LinkScanner, FileProcs, LazFileUtils, LazFileCache,
DirectoryCacher, Avl_Tree, Laz2_XMLCfg, LazDbgLog;
Classes, SysUtils, Laz_Avl_Tree,
// Codetools
SourceLog, LinkScanner, FileProcs, DirectoryCacher,
// LazUtils
LazFileUtils, LazFileCache, Laz2_XMLCfg, LazDbgLog;
const
IncludeLinksFileVersion = 2;
@ -1169,21 +1172,9 @@ end;
procedure TCodeCache.ConsistencyCheck;
// 0 = ok
var ANode: TAVLTreeNode;
{$IF FPC_FULLVERSION<30101}
CurResult: LongInt;
{$ENDIF}
begin
{$IF FPC_FULLVERSION<30101}
CurResult:=FItems.ConsistencyCheck;
if CurResult<>0 then
RaiseCatchableException(IntToStr(CurResult));
CurResult:=FIncludeLinks.ConsistencyCheck;
if CurResult<>0 then
RaiseCatchableException(IntToStr(CurResult));
{$ELSE}
FItems.ConsistencyCheck;
FIncludeLinks.ConsistencyCheck;
{$ENDIF}
ANode:=FItems.FindLowest;
while ANode<>nil do begin
if ANode.Data=nil then

4
components/codetools/codecompletiontool.pas
View File

@ -85,7 +85,7 @@ uses
MemCheck,
{$ENDIF}
// RTL + FCL
Classes, SysUtils, contnrs, AVL_Tree,
Classes, SysUtils, contnrs, Laz_AVL_Tree,
// CodeTools
FileProcs, CodeToolsStrConsts, StdCodeTools,
CodeTree, CodeAtom, CodeCache, CustomCodeTool, PascalParserTool, MethodJumpTool,
@ -95,7 +95,7 @@ uses
CodeCompletionTemplater,
{$ENDIF}
// LazUtils
LazFileUtils, LazDbgLog;
LazFileUtils, LazDbgLog, AvgLvlTree;
type
TNewClassPart = (ncpPrivateProcs, ncpPrivateVars,

21
components/codetools/codegraph.pas
View File

@ -30,7 +30,9 @@ unit CodeGraph;
interface
uses
Classes, SysUtils, CodeTree, FileProcs, AVL_Tree;
Classes, SysUtils, Laz_AVL_Tree,
// Codetools
CodeTree, FileProcs;
type
@ -921,15 +923,8 @@ begin
e('');
if Edges=nil then
e('');
{$IF FPC_FULLVERSION<30101}
if Nodes.ConsistencyCheck<>0 then
e('');
if Edges.ConsistencyCheck<>0 then
e('');
{$ELSE}
Nodes.ConsistencyCheck;
Edges.ConsistencyCheck;
{$ENDIF}
if AVLTreeHasDoubles(Nodes)<>nil then
e('');
if AVLTreeHasDoubles(Edges)<>nil then
@ -939,12 +934,7 @@ begin
while AVLNode<>nil do begin
GraphNode:=TCodeGraphNode(AVLNode.Data);
if GraphNode.InTree<>nil then begin
{$IF FPC_FULLVERSION<30101}
if GraphNode.InTree.ConsistencyCheck<>0 then
e('');
{$ELSE}
GraphNode.InTree.ConsistencyCheck;
{$ENDIF}
if AVLTreeHasDoubles(GraphNode.InTree)<>nil then
e('');
EdgeAVLNode:=GraphNode.InTree.FindLowest;
@ -958,12 +948,7 @@ begin
end;
end;
if GraphNode.OutTree<>nil then begin
{$IF FPC_FULLVERSION<30101}
if GraphNode.InTree.ConsistencyCheck<>0 then
e('');
{$ELSE}
GraphNode.InTree.ConsistencyCheck;
{$ENDIF}
if AVLTreeHasDoubles(GraphNode.OutTree)<>nil then
e('');
EdgeAVLNode:=GraphNode.OutTree.FindLowest;

7
components/codetools/codeindex.pas
View File

@ -30,8 +30,11 @@ unit CodeIndex;
interface
uses
SysUtils, AVL_Tree, CodeTree, CodeCache,
LazFileUtils, StdCodeTools, CodeToolsStructs;
SysUtils, Laz_AVL_Tree,
// LazUtils
LazFileUtils,
// Codetools
CodeTree, CodeCache, StdCodeTools, CodeToolsStructs;
type
TCodeBrowserUnit = class;

7
components/codetools/codetemplatestool.pas
View File

@ -36,9 +36,10 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, FileProcs, CodeTree, CodeAtom, CodeCache, KeywordFuncLists,
LinkScanner, AVL_Tree, SourceChanger,
CustomCodeTool, PascalParserTool, CodeToolsStructs, StdCodeTools;
Classes, SysUtils,
// Codetools
FileProcs, CodeTree, CodeCache, KeywordFuncLists, LinkScanner, BasicCodeTools,
SourceChanger, PascalParserTool, StdCodeTools;
type
TCodeTemplateSyntax = (

28
components/codetools/codetoolmanager.pas
View File

@ -40,15 +40,18 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, contnrs, TypInfo, types, FileProcs, LazFileUtils,
BasicCodeTools, CodeToolsStrConsts, LazFileCache, LazMethodList,
Classes, SysUtils, contnrs, TypInfo, types, Laz_AVL_Tree,
// LazUtils
LazFileUtils, LazFileCache, LazMethodList, LazDbgLog, AvgLvlTree,
// Codetools
FileProcs, BasicCodeTools, CodeToolsStrConsts,
EventCodeTool, CodeTree, CodeAtom, SourceChanger, DefineTemplates, CodeCache,
ExprEval, LinkScanner, KeywordFuncLists, FindOverloads, CodeBeautifier,
FindDeclarationCache, DirectoryCacher, AVL_Tree,
FindDeclarationCache, DirectoryCacher,
PPUCodeTools, LFMTrees, DirectivesTree, CodeCompletionTemplater,
PascalParserTool, CodeToolsConfig, CustomCodeTool, FindDeclarationTool,
IdentCompletionTool, StdCodeTools, ResourceCodeTool, CodeToolsStructs,
CTUnitGraph, ExtractProcTool, LazDbgLog, CodeCompletionTool;
CTUnitGraph, ExtractProcTool;
type
TCodeToolManager = class;
@ -6303,7 +6306,7 @@ var
UnitSetCache: TFPCUnitSetCache;
aConfigCache: TFPCTargetConfigCache;
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
begin
UnitSetCache:=FPCDefinesCache.FindUnitSetWithID(UnitSet,Changed,false);
if UnitSetCache=nil then begin
@ -6318,7 +6321,7 @@ begin
if (aConfigCache=nil) or (aConfigCache.Units=nil) then exit;
Node:=aConfigCache.Units.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
Iterate(Item^.Value);
Node:=aConfigCache.Units.Tree.FindSuccessor(Node);
end;
@ -6353,10 +6356,6 @@ begin
end;
procedure TCodeToolManager.ConsistencyCheck;
{$IF FPC_FULLVERSION<30101}
var
CurResult: LongInt;
{$ENDIF}
begin
if FCurCodeTool<>nil then begin
FCurCodeTool.ConsistencyCheck;
@ -6366,17 +6365,8 @@ begin
SourceCache.ConsistencyCheck;
GlobalValues.ConsistencyCheck;
SourceChangeCache.ConsistencyCheck;
{$IF FPC_FULLVERSION<30101}
CurResult:=FPascalTools.ConsistencyCheck;
if CurResult<>0 then
RaiseCatchableException(IntToStr(CurResult));
CurResult:=FDirectivesTools.ConsistencyCheck;
if CurResult<>0 then
RaiseCatchableException(IntToStr(CurResult));
{$ELSE}
FPascalTools.ConsistencyCheck;
FDirectivesTools.ConsistencyCheck;
{$ENDIF}
end;
procedure TCodeToolManager.WriteDebugReport(WriteTool,

5
components/codetools/codetoolscfgscript.pas
View File

@ -53,8 +53,9 @@ unit CodeToolsCfgScript;
interface
uses
Classes, SysUtils, BasicCodeTools, AVL_Tree, KeywordFuncLists, FileProcs,
typinfo, CodeToolsStrConsts;
Classes, SysUtils, typinfo, Laz_AVL_Tree,
// Codetools
BasicCodeTools, KeywordFuncLists, FileProcs, CodeToolsStrConsts;
type
TCTCSValueType = (

6
components/codetools/codetoolsfpcmsgs.pas
View File

@ -42,7 +42,11 @@ unit CodeToolsFPCMsgs;
interface
uses
Classes, SysUtils, FileProcs, LazUTF8Classes, AVL_Tree;
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
LazUTF8Classes,
// Codetools
FileProcs;
type
TfmiSpecialItem = (

729
components/codetools/codetoolsstructs.pas
View File

@ -32,9 +32,12 @@ unit CodeToolsStructs;
interface
uses
Classes, SysUtils, FileProcs, LazFileUtils, LazUtilities, LazDbgLog,
AVL_Tree, BasicCodeTools;
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
LazUtilities, LazDbgLog, AvgLvlTree,
// Codetools
BasicCodeTools;
type
TResourcestringInsertPolicy = (
rsipNone, // do not add/insert
@ -110,150 +113,13 @@ type
property Items[Key: Pointer]: Pointer read GetItems write SetItems; default;
end;
TStringMap = class;
{ TIdentStringToStringTree }
TStringMapItem = record
Name: string;
end;
PStringMapItem = ^TStringMapItem;
{ TStringMapEnumerator }
TStringMapEnumerator = class
protected
FTree: TAVLTree;
FCurrent: TAVLTreeNode;
public
constructor Create(Tree: TAVLTree);
function MoveNext: boolean;
// "Current" is implemented by the descendant classes
end;
{ TStringMap }
TStringMap = class
TIdentStringToStringTree = class(TStringToStringTree)
private
FCompareKeyItemFunc: TListSortCompare;
FTree: TAVLTree;// tree of PStringMapItem
FCaseSensitive: boolean;
function GetCompareItemsFunc: TListSortCompare;
protected
procedure DisposeItem(p: PStringMapItem); virtual;
function ItemsAreEqual(p1, p2: PStringMapItem): boolean; virtual;
function CreateCopy(Src: PStringMapItem): PStringMapItem; virtual;
public
constructor Create(TheCaseSensitive: boolean);
destructor Destroy; override;
procedure Clear; virtual;
function Contains(const s: string): boolean;
function ContainsIdentifier(P: PChar): boolean;
function FindNodeWithIdentifierAsPrefix(P: PChar): TAVLTreeNode;
procedure GetNames(List: TStrings);
procedure Remove(const Name: string); virtual;
property CaseSensitive: boolean read FCaseSensitive;
property Tree: TAVLTree read FTree; // tree of PStringMapItem
function GetNodeData(AVLNode: TAVLTreeNode): PStringMapItem; inline;
function Count: integer;
function FindNode(const s: string): TAVLTreeNode;
function Equals(OtherTree: TStringMap): boolean; reintroduce;
procedure Assign(Source: TStringMap); virtual;
procedure WriteDebugReport; virtual;
function CalcMemSize: PtrUint; virtual;
property CompareItemsFunc: TListSortCompare read GetCompareItemsFunc;
property CompareKeyItemFunc: TListSortCompare read FCompareKeyItemFunc;
procedure SetCompareFuncs(
const NewCompareItemsFunc, NewCompareKeyItemFunc: TListSortCompare);
end;
TStringToStringTreeItem = record
Name: string;
Value: string;
end;
PStringToStringTreeItem = ^TStringToStringTreeItem;
TStringToStringTree = class;
{ TStringToStringTreeEnumerator }
TStringToStringTreeEnumerator = class(TStringMapEnumerator)
private
function GetCurrent: PStringToStringTreeItem;
public
property Current: PStringToStringTreeItem read GetCurrent;
end;
{ TStringToStringTree }
TStringToStringTree = class(TStringMap)
private
function GetStrings(const s: string): string;
procedure SetStrings(const s: string; const AValue: string);
protected
procedure DisposeItem(p: PStringMapItem); override;
function ItemsAreEqual(p1, p2: PStringMapItem): boolean; override;
function CreateCopy(Src: PStringMapItem): PStringMapItem; override;
public
function GetString(const Name: string; out Value: string): boolean;
procedure Add(const Name, Value: string); virtual;
procedure AddNames(List: TStrings);
property Strings[const s: string]: string read GetStrings write SetStrings; default;
function GetNodeData(AVLNode: TAVLTreeNode): PStringToStringTreeItem; inline;
function AsText: string;
procedure WriteDebugReport; override;
function CalcMemSize: PtrUint; override;
function GetEnumerator: TStringToStringTreeEnumerator;
end;
TStringToPointerTree = class;
TStringToPointerTreeItem = record
Name: string;
Value: Pointer;
end;
PStringToPointerTreeItem = ^TStringToPointerTreeItem;
{ TStringToPointerTreeEnumerator }
TStringToPointerTreeEnumerator = class(TStringMapEnumerator)
private
function GetCurrent: PStringToPointerTreeItem;
public
property Current: PStringToPointerTreeItem read GetCurrent;
end;
{ TStringToPointerTree - Tree contains PStringToPointerTreeItem }
TStringToPointerTree = class(TStringMap)
private
FFreeValues: boolean;
function GetItems(const s: string): Pointer;
procedure SetItems(const s: string; AValue: Pointer);
protected
procedure DisposeItem(p: PStringMapItem); override;
function ItemsAreEqual(p1, p2: PStringMapItem): boolean; override;
function CreateCopy(Src: PStringMapItem): PStringMapItem; override;
public
function GetItem(const Name: string; out Value: Pointer): boolean;
procedure Add(const Name: string; const Value: Pointer); virtual;
property Items[const s: string]: Pointer read GetItems write SetItems; default;
function GetNodeData(AVLNode: TAVLTreeNode): PStringToPointerTreeItem; inline;
procedure Assign(Source: TStringMap); override;
function GetEnumerator: TStringToPointerTreeEnumerator;
property FreeValues: boolean read FFreeValues write FFreeValues;
end;
{ TFilenameToStringTree }
TFilenameToStringTree = class(TStringToStringTree)
public
constructor Create(CaseInsensitive: boolean); // false = system default
end;
{ TFilenameToPointerTree }
TFilenameToPointerTree = class(TStringToPointerTree)
public
constructor Create(CaseInsensitive: boolean); // false = system default
end;
TStringTree = class;
@ -308,30 +174,27 @@ function ComparePointerToPointerItems(Data1, Data2: Pointer): integer;
function ComparePointerAndP2PItem(Key, Data: Pointer): integer;
// case sensitive
function CompareStringToStringItems(Data1, Data2: Pointer): integer;
function CompareStringAndStringToStringTreeItem(Key, Data: Pointer): integer;
function CompareIdentifierAndStringToStringTreeItem(Identifier, Data: Pointer): integer;
//function CompareStringToStringItems(Data1, Data2: Pointer): integer;
//function CompareStringAndStringToStringTreeItem(Key, Data: Pointer): integer;
//function CompareIdentifierAndStringToStringTreeItem(Identifier, Data: Pointer): integer;
function CompareIdentifierPrefixAndStringToStringTreeItem(Identifier, Data: Pointer): integer;
// case insensitive
function CompareStringToStringItemsI(Data1, Data2: Pointer): integer;
function CompareStringAndStringToStringTreeItemI(Key, Data: Pointer): integer;
function CompareIdentifierAndStringToStringTreeItemI(Identifier, Data: Pointer): integer;
//function CompareStringToStringItemsI(Data1, Data2: Pointer): integer;
//function CompareStringAndStringToStringTreeItemI(Key, Data: Pointer): integer;
//function CompareIdentifierAndStringToStringTreeItemI(Identifier, Data: Pointer): integer;
function CompareIdentifierPrefixAndStringToStringTreeItemI(Identifier, Data: Pointer): integer;
function CompareFilenameToStringItems(Data1, Data2: Pointer): integer;
function CompareFilenameAndFilenameToStringTreeItem(Key, Data: Pointer): integer;
//function CompareFilenameToStringItems(Data1, Data2: Pointer): integer;
//function CompareFilenameAndFilenameToStringTreeItem(Key, Data: Pointer): integer;
function CompareFilenameToStringItemsI(Data1, Data2: Pointer): integer;
function CompareFilenameAndFilenameToStringTreeItemI(Key, Data: Pointer): integer;
//function CompareFilenameToStringItemsI(Data1, Data2: Pointer): integer;
//function CompareFilenameAndFilenameToStringTreeItemI(Key, Data: Pointer): integer;
function CompareAnsiStringPtrs(Data1, Data2: Pointer): integer;
{$IF FPC_FULLVERSION<20601}
{$DEFINE EnableAVLFindPointerFix}
{$ENDIF}
function AVLFindPointer(Tree: TAVLTree; Data: Pointer): TAVLTreeNode; {$IFNDEF EnableAVLFindPointerFix}inline;{$ENDIF}
procedure AVLRemovePointer(Tree: TAVLTree; Data: Pointer); {$IFNDEF EnableAVLFindPointerFix}inline;{$ENDIF}
function AVLFindPointer(Tree: TAVLTree; Data: Pointer): TAVLTreeNode; inline;
procedure AVLRemovePointer(Tree: TAVLTree; Data: Pointer); inline;
implementation
@ -349,7 +212,7 @@ var
begin
Result:=ComparePointers(Key,P2PItem^.Key);
end;
{
function CompareStringToStringItems(Data1, Data2: Pointer): integer;
begin
Result:=CompareStr(PStringToStringTreeItem(Data1)^.Name,
@ -393,16 +256,15 @@ begin
Result:=-1;
end;
end;
function CompareIdentifierPrefixAndStringToStringTreeItem(Identifier,
Data: Pointer): integer;
}
function CompareIdentifierPrefixAndStringToStringTreeItem(Identifier, Data: Pointer): integer;
var
Id: PChar absolute Identifier;
Item: PStringToStringTreeItem absolute Data;
Item: PStringToStringItem absolute Data;
begin
Result:=-CompareIdentifiersCaseSensitive(Id,PChar(Item^.Name));
end;
{
function CompareStringAndStringToStringTreeItemI(Key, Data: Pointer): integer;
begin
Result:=CompareText(String(Key),PStringToStringTreeItem(Data)^.Name);
@ -428,18 +290,16 @@ begin
Result:=-1;
end;
end;
function CompareIdentifierPrefixAndStringToStringTreeItemI(Identifier,
Data: Pointer): integer;
}
function CompareIdentifierPrefixAndStringToStringTreeItemI(Identifier, Data: Pointer): integer;
var
Id: PChar absolute Identifier;
Item: PStringToStringTreeItem absolute Data;
Item: PStringToStringItem absolute Data;
begin
Result:=-CompareIdentifiers(Id,PChar(Item^.Name));
end;
function CompareFilenameAndFilenameToStringTreeItem(Key, Data: Pointer
): integer;
{
function CompareFilenameAndFilenameToStringTreeItem(Key, Data: Pointer): integer;
begin
Result:=CompareFilenames(String(Key),PStringToStringTreeItem(Data)^.Name);
end;
@ -450,13 +310,12 @@ begin
PStringToStringTreeItem(Data2)^.Name);
end;
function CompareFilenameAndFilenameToStringTreeItemI(Key, Data: Pointer
): integer;
function CompareFilenameAndFilenameToStringTreeItemI(Key, Data: Pointer): integer;
begin
Result:=CompareFilenamesIgnoreCase(String(Key),
PStringToStringTreeItem(Data)^.Name);
end;
}
function CompareAnsiStringPtrs(Data1, Data2: Pointer): integer;
begin
Result:=CompareStr(AnsiString(Data1),AnsiString(Data2));
@ -464,32 +323,12 @@ end;
function AVLFindPointer(Tree: TAVLTree; Data: Pointer): TAVLTreeNode;
begin
{$IFDEF EnableAVLFindPointerFix}
Result:=Tree.FindLeftMost(Data);
while (Result<>nil) do begin
if Result.Data=Data then break;
Result:=Tree.FindSuccessor(Result);
if Result=nil then exit;
if Tree.OnCompare(Data,Result.Data)<>0 then exit(nil);
end;
{$ELSE}
Result:=Tree.FindPointer(Data);
{$ENDIF}
end;
procedure AVLRemovePointer(Tree: TAVLTree; Data: Pointer);
{$IFDEF EnableAVLFindPointerFix}
var
Node: TAVLTreeNode;
{$ENDIF}
begin
{$IFDEF EnableAVLFindPointerFix}
Node:=AVLFindPointer(Tree,Data);
if Node<>nil then
Tree.Delete(Node);
{$ELSE}
Tree.RemovePointer(Data);
{$ENDIF}
end;
{ TPointerToPointerTree }
@ -568,8 +407,7 @@ begin
end;
end;
function TPointerToPointerTree.GetNodeData(AVLNode: TAVLTreeNode
): PPointerToPointerItem;
function TPointerToPointerTree.GetNodeData(AVLNode: TAVLTreeNode): PPointerToPointerItem;
begin
Result:=PPointerToPointerItem(AVLNode.Data);
end;
@ -616,349 +454,14 @@ begin
Result:=TAVLTreeNode.Create;
end;
{ TFilenameToPointerTree }
{ TIdentStringToStringTree }
constructor TFilenameToPointerTree.Create(CaseInsensitive: boolean);
begin
inherited Create(true);
if CaseInsensitive then
SetCompareFuncs(@CompareFilenameToStringItemsI,
@CompareFilenameAndFilenameToStringTreeItemI)
else
SetCompareFuncs(@CompareFilenameToStringItems,
@CompareFilenameAndFilenameToStringTreeItem);
end;
{ TStringToPointerTree }
function TStringToPointerTree.GetItems(const s: string): Pointer;
var
Node: TAVLTreeNode;
begin
Node:=FindNode(s);
if Node<>nil then
Result:=PStringToPointerTreeItem(Node.Data)^.Value
else
Result:=nil;
end;
procedure TStringToPointerTree.SetItems(const s: string; AValue: Pointer);
var
Node: TAVLTreeNode;
NewItem: PStringToPointerTreeItem;
begin
Node:=FindNode(s);
if Node<>nil then begin
NewItem:=PStringToPointerTreeItem(Node.Data);
if FreeValues then
TObject(NewItem^.Value).Free;
NewItem^.Value:=AValue;
end else begin
New(NewItem);
NewItem^.Name:=s;
NewItem^.Value:=AValue;
FTree.Add(NewItem);
end;
end;
procedure TStringToPointerTree.DisposeItem(p: PStringMapItem);
var
Item: PStringToPointerTreeItem absolute p;
begin
if FreeValues then
TObject(Item^.Value).Free;
Dispose(Item);
end;
function TStringToPointerTree.ItemsAreEqual(p1, p2: PStringMapItem): boolean;
var
Item1: PStringToPointerTreeItem absolute p1;
Item2: PStringToPointerTreeItem absolute p2;
begin
Result:=(Item1^.Name=Item2^.Name)
and (Item1^.Value=Item2^.Value);
end;
function TStringToPointerTree.CreateCopy(Src: PStringMapItem): PStringMapItem;
var
SrcItem: PStringToPointerTreeItem absolute Src;
NewItem: PStringToPointerTreeItem;
begin
New(NewItem);
NewItem^.Name:=SrcItem^.Name;
NewItem^.Value:=SrcItem^.Value;
Result:=PStringMapItem(NewItem);
end;
function TStringToPointerTree.GetItem(const Name: string; out Value: Pointer
): boolean;
var
Node: TAVLTreeNode;
begin
Node:=FindNode(Name);
if Node<>nil then begin
Value:=PStringToPointerTreeItem(Node.Data)^.Value;
Result:=true;
end else begin
Result:=false;
end;
end;
procedure TStringToPointerTree.Add(const Name: string; const Value: Pointer);
begin
Items[Name]:=Value;
end;
function TStringToPointerTree.GetNodeData(AVLNode: TAVLTreeNode
): PStringToPointerTreeItem;
begin
Result:=PStringToPointerTreeItem(AVLNode.Data);
end;
procedure TStringToPointerTree.Assign(Source: TStringMap);
var
Node: TAVLTreeNode;
Item: PStringToPointerTreeItem;
begin
if (Source=nil) or (Source.ClassType<>ClassType) then
raise Exception.Create('invalid class');
Clear;
Node:=Source.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToPointerTreeItem(Node.Data);
Items[Item^.Name]:=Item^.Value;
Node:=Source.Tree.FindSuccessor(Node);
end;
end;
function TStringToPointerTree.GetEnumerator: TStringToPointerTreeEnumerator;
begin
Result:=TStringToPointerTreeEnumerator.Create(FTree);
end;
{ TStringMapEnumerator }
constructor TStringMapEnumerator.Create(Tree: TAVLTree);
begin
FTree:=Tree;
end;
function TStringMapEnumerator.MoveNext: boolean;
begin
if FCurrent=nil then
FCurrent:=FTree.FindLowest
else
FCurrent:=FTree.FindSuccessor(FCurrent);
Result:=FCurrent<>nil;
end;
{ TStringToPointerTreeEnumerator }
function TStringToPointerTreeEnumerator.GetCurrent: PStringToPointerTreeItem;
begin
Result:=PStringToPointerTreeItem(FCurrent.Data);
end;
{ TStringMap }
function TStringMap.GetCompareItemsFunc: TListSortCompare;
begin
Result:=Tree.OnCompare;
end;
function TStringMap.FindNode(const s: string): TAVLTreeNode;
begin
Result:=FTree.FindKey(Pointer(s),FCompareKeyItemFunc);
end;
procedure TStringMap.DisposeItem(p: PStringMapItem);
begin
Dispose(p);
end;
function TStringMap.ItemsAreEqual(p1, p2: PStringMapItem): boolean;
begin
Result:=p1^.Name=p2^.Name;
end;
function TStringMap.CreateCopy(Src: PStringMapItem): PStringMapItem;
begin
New(Result);
Result^.Name:=Src^.Name;
end;
constructor TStringMap.Create(TheCaseSensitive: boolean);
begin
FCaseSensitive:=TheCaseSensitive;
if CaseSensitive then begin
FCompareKeyItemFunc:=@CompareStringAndStringToStringTreeItem;
FTree:=TMTAVLTree.Create(@CompareStringToStringItems);
end else begin
FCompareKeyItemFunc:=@CompareStringAndStringToStringTreeItemI;
FTree:=TMTAVLTree.Create(@CompareStringToStringItemsI);
end;
end;
destructor TStringMap.Destroy;
begin
Clear;
FTree.Free;
FTree:=nil;
inherited Destroy;
end;
procedure TStringMap.Clear;
var
Node: TAVLTreeNode;
begin
Node:=FTree.FindLowest;
while Node<>nil do begin
DisposeItem(PStringMapItem(Node.Data));
Node:=FTree.FindSuccessor(Node);
end;
FTree.Clear;
end;
function TStringMap.Contains(const s: string): boolean;
begin
Result:=FindNode(s)<>nil;
end;
function TStringMap.ContainsIdentifier(P: PChar): boolean;
function TIdentStringToStringTree.FindNodeWithIdentifierAsPrefix(P: PChar): TAVLTreeNode;
begin
if CaseSensitive then
Result:=FTree.FindKey(p,@CompareIdentifierAndStringToStringTreeItem)<>nil
Result:=Tree.FindKey(p,@CompareIdentifierPrefixAndStringToStringTreeItem)
else
Result:=FTree.FindKey(p,@CompareIdentifierAndStringToStringTreeItemI)<>nil;
end;
function TStringMap.FindNodeWithIdentifierAsPrefix(P: PChar): TAVLTreeNode;
begin
if CaseSensitive then
Result:=FTree.FindKey(p,@CompareIdentifierPrefixAndStringToStringTreeItem)
else
Result:=FTree.FindKey(p,@CompareIdentifierPrefixAndStringToStringTreeItemI);
end;
procedure TStringMap.GetNames(List: TStrings);
var
Node: TAVLTreeNode;
Item: PStringMapItem;
begin
Node:=Tree.FindLowest;
while Node<>nil do begin
Item:=PStringMapItem(Node.Data);
List.Add(Item^.Name);
Node:=Tree.FindSuccessor(Node);
end;
end;
procedure TStringMap.Remove(const Name: string);
var
Node: TAVLTreeNode;
Item: PStringMapItem;
begin
Node:=FindNode(Name);
if Node<>nil then begin
Item:=PStringMapItem(Node.Data);
FTree.Delete(Node);
DisposeItem(Item);
end;
end;
function TStringMap.GetNodeData(AVLNode: TAVLTreeNode): PStringMapItem;
begin
Result:=PStringMapItem(AVLNode.Data);
end;
function TStringMap.Count: integer;
begin
Result:=Tree.Count;
end;
function TStringMap.Equals(OtherTree: TStringMap): boolean;
var
Node: TAVLTreeNode;
OtherNode: TAVLTreeNode;
OtherItem: PStringMapItem;
Item: PStringMapItem;
begin
Result:=false;
if (OtherTree=nil) or (OtherTree.ClassType<>ClassType) then exit;
if Tree.Count<>OtherTree.Tree.Count then exit;
Node:=Tree.FindLowest;
OtherNode:=OtherTree.Tree.FindLowest;
while Node<>nil do begin
if OtherNode=nil then exit;
Item:=PStringMapItem(Node.Data);
OtherItem:=PStringMapItem(OtherNode.Data);
if not ItemsAreEqual(Item,OtherItem) then exit;
OtherNode:=OtherTree.Tree.FindSuccessor(OtherNode);
Node:=Tree.FindSuccessor(Node);
end;
if OtherNode<>nil then exit;
Result:=true;
end;
procedure TStringMap.Assign(Source: TStringMap);
var
SrcNode: TAVLTreeNode;
SrcItem: PStringMapItem;
begin
if (Source=nil) or (Source.ClassType<>ClassType) then
raise Exception.Create('invalid class');
Clear;
SrcNode:=Source.Tree.FindLowest;
while SrcNode<>nil do begin
SrcItem:=PStringMapItem(SrcNode.Data);
Tree.Add(CreateCopy(SrcItem));
SrcNode:=Source.Tree.FindSuccessor(SrcNode);
end;
end;
procedure TStringMap.WriteDebugReport;
var
Node: TAVLTreeNode;
Item: PStringMapItem;
begin
DebugLn(['TStringMap.WriteDebugReport ',Tree.Count]);
Node:=Tree.FindLowest;
while Node<>nil do begin
Item:=PStringMapItem(Node.Data);
DebugLn([Item^.Name]);
Node:=Tree.FindSuccessor(Node);
end;
end;
function TStringMap.CalcMemSize: PtrUint;
var
Node: TAVLTreeNode;
Item: PStringMapItem;
begin
Result:=PtrUInt(InstanceSize)
+PtrUInt(FTree.InstanceSize)
+PtrUint(FTree.Count)*SizeOf(TAVLTreeNode);
Node:=FTree.FindLowest;
while Node<>nil do begin
Item:=PStringMapItem(Node.Data);
inc(Result,MemSizeString(Item^.Name)
+SizeOf(TStringMapItem));
Node:=FTree.FindSuccessor(Node);
end;
end;
procedure TStringMap.SetCompareFuncs(const NewCompareItemsFunc,
NewCompareKeyItemFunc: TListSortCompare);
begin
FCompareKeyItemFunc:=NewCompareKeyItemFunc;
Tree.OnCompare:=NewCompareItemsFunc;
end;
{ TStringToStringTreeEnumerator }
function TStringToStringTreeEnumerator.GetCurrent: PStringToStringTreeItem;
begin
Result:=PStringToStringTreeItem(FCurrent.Data);
Result:=Tree.FindKey(p,@CompareIdentifierPrefixAndStringToStringTreeItemI);
end;
{ TStringTreeEnumerator }
@ -982,164 +485,6 @@ begin
Result:=FCurrent<>nil;
end;
{ TStringToStringTree }
function TStringToStringTree.GetStrings(const s: string): string;
var
Node: TAVLTreeNode;
begin
Node:=FindNode(s);
if Node<>nil then
Result:=PStringToStringTreeItem(Node.Data)^.Value
else
Result:='';
end;
procedure TStringToStringTree.SetStrings(const s: string; const AValue: string);
var
Node: TAVLTreeNode;
NewItem: PStringToStringTreeItem;
begin
Node:=FindNode(s);
if Node<>nil then begin
PStringToStringTreeItem(Node.Data)^.Value:=AValue;
end else begin
New(NewItem);
NewItem^.Name:=s;
NewItem^.Value:=AValue;
FTree.Add(NewItem);
end;
end;
procedure TStringToStringTree.DisposeItem(p: PStringMapItem);
var
Item: PStringToStringTreeItem absolute p;
begin
Dispose(Item);
end;
function TStringToStringTree.ItemsAreEqual(p1, p2: PStringMapItem): boolean;
var
Item1: PStringToStringTreeItem absolute p1;
Item2: PStringToStringTreeItem absolute p2;
begin
Result:=(Item1^.Name=Item2^.Name)
and (Item1^.Value=Item2^.Value);
end;
function TStringToStringTree.CreateCopy(Src: PStringMapItem): PStringMapItem;
var
SrcItem: PStringToStringTreeItem absolute Src;
NewItem: PStringToStringTreeItem;
begin
New(NewItem);
NewItem^.Name:=SrcItem^.Name;
NewItem^.Value:=SrcItem^.Value;
Result:=PStringMapItem(NewItem);
end;
function TStringToStringTree.GetString(const Name: string; out Value: string
): boolean;
var
Node: TAVLTreeNode;
begin
Node:=FindNode(Name);
if Node<>nil then begin
Value:=PStringToStringTreeItem(Node.Data)^.Value;
Result:=true;
end else begin
Result:=false;
end;
end;
procedure TStringToStringTree.Add(const Name, Value: string);
begin
Strings[Name]:=Value;
end;
procedure TStringToStringTree.AddNames(List: TStrings);
var
i: Integer;
aName: String;
begin
if List=nil then exit;
for i:=0 to List.Count-1 do begin
aName:=List[i];
if not Contains(aName) then
Strings[aName]:='';
end;
end;
function TStringToStringTree.GetNodeData(AVLNode: TAVLTreeNode
): PStringToStringTreeItem;
begin
Result:=PStringToStringTreeItem(AVLNode.Data);
end;
function TStringToStringTree.AsText: string;
var
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
begin
Result:='';
Node:=Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Result:=Result+Item^.Name+'='+Item^.Value+LineEnding;
Node:=Tree.FindSuccessor(Node);
end;
end;
procedure TStringToStringTree.WriteDebugReport;
var
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
begin
DebugLn(['TStringToStringTree.WriteDebugReport ',Tree.Count]);
Node:=Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
DebugLn([Item^.Name,'=',Item^.Value]);
Node:=Tree.FindSuccessor(Node);
end;
end;
function TStringToStringTree.CalcMemSize: PtrUint;
var
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
begin
Result:=PtrUInt(InstanceSize)
+PtrUInt(FTree.InstanceSize)
+PtrUint(FTree.Count)*SizeOf(TAVLTreeNode);
Node:=FTree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
inc(Result,MemSizeString(Item^.Name)
+MemSizeString(Item^.Value)
+SizeOf(TStringToStringTreeItem));
Node:=FTree.FindSuccessor(Node);
end;
end;
function TStringToStringTree.GetEnumerator: TStringToStringTreeEnumerator;
begin
Result:=TStringToStringTreeEnumerator.Create(FTree);
end;
{ TFilenameToStringTree }
constructor TFilenameToStringTree.Create(CaseInsensitive: boolean);
begin
inherited Create(true);
if CaseInsensitive then
SetCompareFuncs(@CompareFilenameToStringItemsI,
@CompareFilenameAndFilenameToStringTreeItemI)
else
SetCompareFuncs(@CompareFilenameToStringItems,
@CompareFilenameAndFilenameToStringTreeItem);
end;
{ TStringTree }
constructor TStringTree.Create;

7
components/codetools/codetree.pas
View File

@ -42,8 +42,11 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, FileProcs, CodeToolsStructs, BasicCodeTools,
AVL_Tree, LazDbgLog;
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
LazDbgLog,
// Codetools
FileProcs, CodeToolsStructs, BasicCodeTools;
//-----------------------------------------------------------------------------

16
components/codetools/ctunitgraph.pas
View File

@ -30,9 +30,12 @@ unit CTUnitGraph;
interface
uses
Classes, SysUtils, AVL_Tree, FileProcs, LazFileUtils, LazUtilities,
FindDeclarationTool, CodeBeautifier, CodeCache, StdCodeTools, DirectoryCacher,
LinkScanner, CustomCodeTool, CodeTree, CodeToolsStructs;
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
LazFileUtils, LazUtilities,
// Codetools
FileProcs, FindDeclarationTool, CodeBeautifier, CodeCache, StdCodeTools,
DirectoryCacher, LinkScanner, CustomCodeTool, CodeTree, CodeToolsStructs;
type
@ -267,15 +270,8 @@ var
AVLNode: TAVLTreeNode;
AnUnit: TUGUnit;
begin
{$IF FPC_FULLVERSION<30101}
if FFiles.ConsistencyCheck<>0 then
raise Exception.Create('FFiles.ConsistencyCheck');
if FQueuedFiles.ConsistencyCheck<>0 then
raise Exception.Create('FStartFiles.ConsistencyCheck');
{$ELSE}
FFiles.ConsistencyCheck;
FQueuedFiles.ConsistencyCheck;
{$ENDIF}
AVLNode:=FQueuedFiles.FindLowest;
while AVLNode<>nil do begin

2
components/codetools/ctunitgroupgraph.pas
View File

@ -30,7 +30,7 @@ unit CTUnitGroupGraph;
interface
uses
Classes, SysUtils, AVL_Tree, CTUnitGraph;
Classes, SysUtils, Laz_AVL_Tree, CTUnitGraph;
type
TUGGroup = class;

7
components/codetools/customcodetool.pas
View File

@ -43,9 +43,12 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, FileProcs, CodeToolsStrConsts, CodeTree, CodeAtom,
Classes, SysUtils, Laz_AVL_Tree,
// Codetools
FileProcs, CodeToolsStrConsts, CodeTree, CodeAtom,
KeywordFuncLists, BasicCodeTools, LinkScanner, CodeCache,
LazFileUtils, LazUtilities, AVL_Tree, LazDbgLog;
// LazUtils
LazFileUtils, LazUtilities, LazDbgLog;
type
TCodeToolPhase = (

45
components/codetools/definetemplates.pas
View File

@ -54,13 +54,13 @@ interface
uses
// RTL + FCL
Classes, SysUtils, AVL_Tree, contnrs, process,
Classes, SysUtils, contnrs, process, Laz_AVL_Tree,
// CodeTools
CodeToolsStrConsts, ExprEval, DirectoryCacher, BasicCodeTools,
CodeToolsStructs, KeywordFuncLists, LinkScanner, FileProcs,
// LazUtils
LazUtilities, LazUTF8, LazUTF8Classes, LazFileUtils, UTF8Process,
LazFileCache, LazDbgLog, Laz2_XMLCfg;
LazFileCache, LazDbgLog, AvgLvlTree, Laz2_XMLCfg;
const
ExternalMacroStart = ExprEval.ExternalMacroStart;
@ -1811,7 +1811,7 @@ var
Ext: String;
File_Name, PkgName, FPMFilename, FPMSourcePath, Line, SrcFilename: String;
AVLNode: TAVLTreeNode;
S2SItem: PStringToStringTreeItem;
S2SItem: PStringToStringItem;
FPMToUnitTree: TStringToPointerTree;// pkgname to TStringToStringTree (unitname to source filename)
sl: TStringListUTF8;
PkgUnitToFilename: TStringToStringTree;
@ -1888,7 +1888,7 @@ begin
try
AVLNode:=Units.Tree.FindLowest;
while AVLNode<>nil do begin
S2SItem:=PStringToStringTreeItem(AVLNode.Data);
S2SItem:=PStringToStringItem(AVLNode.Data);
File_Name:=S2SItem^.Name;
Filename:=S2SItem^.Value; // trimmed and expanded filename
//if Pos('lazmkunit',Filename)>0 then
@ -2189,11 +2189,10 @@ begin
end;
end;
function CreateFPCTemplate(Config: TFPCTargetConfigCache; Owner: TObject
): TDefineTemplate;
function CreateFPCTemplate(Config: TFPCTargetConfigCache; Owner: TObject): TDefineTemplate;
var
Node: TAVLTreeNode;
StrItem: PStringToStringTreeItem;
StrItem: PStringToStringItem;
NewDefTempl: TDefineTemplate;
TargetOS: String;
SrcOS: String;
@ -2242,7 +2241,7 @@ begin
if Config.Defines<>nil then begin
Node:=Config.Defines.Tree.FindLowest;
while Node<>nil do begin
StrItem:=PStringToStringTreeItem(Node.Data);
StrItem:=PStringToStringItem(Node.Data);
NewDefTempl:=TDefineTemplate.Create('Define '+StrItem^.Name,
'Macro',StrItem^.Name,StrItem^.Value,da_DefineRecurse);
Result.AddChild(NewDefTempl);
@ -2253,7 +2252,7 @@ begin
if Config.Undefines<>nil then begin
Node:=Config.Undefines.Tree.FindLowest;
while Node<>nil do begin
StrItem:=PStringToStringTreeItem(Node.Data);
StrItem:=PStringToStringItem(Node.Data);
NewDefTempl:=TDefineTemplate.Create('Undefine '+StrItem^.Name,
'Macro',StrItem^.Name,'',da_UndefineRecurse);
Result.AddChild(NewDefTempl);
@ -2265,16 +2264,14 @@ begin
Result.SetDefineOwner(Owner,true);
end;
function CreateFPCTemplate(Config: TFPCUnitSetCache; Owner: TObject
): TDefineTemplate; overload;
function CreateFPCTemplate(Config: TFPCUnitSetCache; Owner: TObject): TDefineTemplate; overload;
begin
Result:=CreateFPCTemplate(Config.GetConfigCache(false),Owner);
Result.AddChild(TDefineTemplate.Create('UnitSet','UnitSet identifier',
UnitSetMacroName,Config.GetUnitSetID,da_DefineRecurse));
end;
function CreateFPCSourceTemplate(FPCSrcDir: string; Owner: TObject
): TDefineTemplate;
function CreateFPCSourceTemplate(FPCSrcDir: string; Owner: TObject): TDefineTemplate;
const
RTLPkgDirs: array[1..4] of string = ('rtl-console','rtl-extra','rtl-objpas','rtl-unicode');
var
@ -2690,7 +2687,7 @@ procedure CheckPPUSources(PPUFiles, UnitToSource,
var Duplicates, Missing: TStringToStringTree);
var
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
Unit_Name: String;
Filename: String;
SrcFilename: string;
@ -2708,7 +2705,7 @@ begin
raise Exception.Create('CheckPPUSources Missing is case sensitive');
Node:=PPUFiles.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
Unit_Name:=Item^.Name;
Filename:=Item^.Value;
if CompareFileExt(Filename,'.ppu',false)=0 then begin
@ -5646,20 +5643,10 @@ begin
end;
procedure TDefineTree.ConsistencyCheck;
{$IF FPC_FULLVERSION<30101}
var
CurResult: LongInt;
{$ENDIF}
begin
if FFirstDefineTemplate<>nil then
FFirstDefineTemplate.ConsistencyCheck;
{$IF FPC_FULLVERSION<30101}
CurResult:=FCache.ConsistencyCheck;
if CurResult<>0 then
RaiseCatchableException(IntToStr(CurResult));
{$ELSE}
FCache.ConsistencyCheck;
{$ENDIF}
end;
procedure TDefineTree.CalcMemSize(Stats: TCTMemStats);
@ -8548,7 +8535,7 @@ procedure TFPCTargetConfigCache.SaveToXMLConfig(XMLConfig: TXMLConfig;
const Path: string);
var
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
Cnt: Integer;
SubPath: String;
s: String;
@ -8597,7 +8584,7 @@ var
// Create a string list of filenames
Node:=ASource.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
Filename:=Item^.Value;
FileList.Add(Filename);
Node:=ASource.Tree.FindSuccessor(Node);
@ -8639,7 +8626,7 @@ begin
if Defines<>nil then begin
Node:=Defines.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
if IsValidIdent(Item^.Name) then begin
inc(Cnt);
SubPath:=Path+'Defines/Macro'+IntToStr(Cnt)+'/';
@ -8657,7 +8644,7 @@ begin
if Undefines<>nil then begin
Node:=Undefines.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
inc(Cnt);
if s<>'' then s:=s+',';
s:=s+Item^.Name;

5
components/codetools/directivestree.pas
View File

@ -37,8 +37,9 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, FileProcs, LazFileUtils,
BasicCodeTools, KeywordFuncLists, CodeCache, AVL_Tree, ExprEval, CodeTree;
Classes, SysUtils, Laz_AVL_Tree,
// Codetools
FileProcs, BasicCodeTools, KeywordFuncLists, CodeCache, ExprEval, CodeTree;
type
TCompilerDirectiveNodeDesc = word;

6
components/codetools/directorycacher.pas
View File

@ -36,11 +36,11 @@ interface
uses
// RTL + FCL
Classes, SysUtils, AVL_Tree,
Classes, SysUtils, Laz_AVL_Tree,
// CodeTools
CodeToolsStructs, FileProcs,
FileProcs,
// LazUtils
LazUTF8, LazFileCache, LazFileUtils, LazUtilities, LazDbgLog;
LazUTF8, LazFileCache, LazFileUtils, LazUtilities, AvgLvlTree, LazDbgLog;
// verbosity
{ $DEFINE CTDEBUG}

11
components/codetools/eventcodetool.pas
View File

@ -43,10 +43,13 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, TypInfo, FileProcs, LazFileUtils, CodeToolsStrConsts,
CodeTree, CodeCache, PascalParserTool, CodeCompletionTool, KeywordFuncLists,
BasicCodeTools, LinkScanner, AVL_Tree, CodeToolsStructs,
SourceChanger, FindDeclarationTool, ChangeDeclarationTool;
Classes, SysUtils, TypInfo, Laz_AVL_Tree,
// LazUtils
LazFileUtils,
// Codetools
FileProcs, CodeToolsStrConsts, CodeTree, CodeCache, PascalParserTool,
CodeCompletionTool, KeywordFuncLists, BasicCodeTools, LinkScanner,
CodeToolsStructs, SourceChanger, FindDeclarationTool, ChangeDeclarationTool;
type
{ TEventsCodeTool }

7
components/codetools/extractproctool.pas
View File

@ -51,11 +51,12 @@ unit ExtractProcTool;
interface
uses
Classes, SysUtils, math, FileProcs, CodeToolsStrConsts, CodeTree, CodeAtom,
Classes, SysUtils, math, Laz_AVL_Tree,
// Codetools
FileProcs, CodeToolsStrConsts, CodeTree, CodeAtom,
CodeCache, CustomCodeTool, PascalReaderTool,
PascalParserTool, CodeCompletionTool, KeywordFuncLists, BasicCodeTools,
LinkScanner, AVL_Tree, SourceChanger,
FindDeclarationTool;
LinkScanner, SourceChanger, FindDeclarationTool;
type
TExtractedProcVariableType = (

5
components/codetools/fileprocs.pas
View File

@ -40,7 +40,7 @@ uses
Windows,
{$ENDIF}
// RTL + FCL
Classes, SysUtils, AVL_Tree,
Classes, SysUtils, Laz_AVL_Tree,
// CodeTools
CodeToolsStrConsts,
// LazUtils
@ -48,8 +48,7 @@ uses
{$IFDEF EnableWrapperFunctions}
LazDbgLog,
{$ENDIF}
LazLogger, LazUTF8, LazFileCache,
LazFileUtils, LazUTF8Classes;
LazLogger, LazFileCache, LazFileUtils, LazUTF8, LazUTF8Classes;
type
TFPCStreamSeekType = int64;

20
components/codetools/finddeclarationcache.pas
View File

@ -37,9 +37,10 @@ interface
{ $DEFINE HardExceptions}
uses
Classes, SysUtils, FileProcs, BasicCodeTools, CodeTree, LinkScanner,
AVL_Tree, PascalParserTool, KeywordFuncLists,
CodeToolMemManager;
Classes, SysUtils, Laz_AVL_Tree,
// Codetools
FileProcs, BasicCodeTools, CodeTree, LinkScanner,
PascalParserTool, KeywordFuncLists, CodeToolMemManager;
type
{
@ -489,12 +490,7 @@ var
Entry: PInterfaceIdentCacheEntry;
begin
if FItems<>nil then begin
{$IF FPC_FULLVERSION<30101}
if FItems.ConsistencyCheck<>0 then
RaiseCatchableException('');
{$ELSE}
FItems.ConsistencyCheck;
{$ENDIF}
Node:=FItems.FindLowest;
while Node<>nil do begin
Entry:=PInterfaceIdentCacheEntry(Node.Data);
@ -1054,14 +1050,8 @@ end;
procedure TCodeTreeNodeCache.ConsistencyCheck;
begin
if (FItems<>nil) then begin
{$IF FPC_FULLVERSION<30101}
if FItems.ConsistencyCheck<>0 then
raise Exception.Create('');
{$ELSE}
if (FItems<>nil) then
FItems.ConsistencyCheck;
{$ENDIF}
end;
if Owner<>nil then begin
if Owner.Cache<>Self then
raise Exception.Create('');

25
components/codetools/finddeclarationtool.pas
View File

@ -77,10 +77,13 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, CodeToolsStrConsts, CodeTree, CodeAtom, CustomCodeTool,
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
LazFileUtils, LazUtilities,
// Codetools
CodeToolsStrConsts, CodeTree, CodeAtom, CustomCodeTool,
SourceLog, KeywordFuncLists, BasicCodeTools, LinkScanner, CodeCache,
DirectoryCacher, AVL_Tree, PascalParserTool,
PascalReaderTool, FileProcs, LazFileUtils, LazUtilities, LazUTF8,
DirectoryCacher, PascalParserTool, PascalReaderTool, FileProcs,
DefineTemplates, FindDeclarationCache;
type
@ -11687,22 +11690,10 @@ begin
ANodeCache.ConsistencyCheck;
ANodeCache:=ANodeCache.Next;
end;
if FDependentCodeTools<>nil then begin
{$IF FPC_FULLVERSION<30101}
if FDependentCodeTools.ConsistencyCheck<>0 then
raise Exception.Create('');
{$ELSE}
if FDependentCodeTools<>nil then
FDependentCodeTools.ConsistencyCheck;
{$ENDIF}
end;
if FDependsOnCodeTools<>nil then begin
{$IF FPC_FULLVERSION<30101}
if FDependsOnCodeTools.ConsistencyCheck<>0 then
raise Exception.Create('');
{$ELSE}
if FDependsOnCodeTools<>nil then
FDependsOnCodeTools.ConsistencyCheck;
{$ENDIF}
end;
end;
procedure TFindDeclarationTool.CalcMemSize(Stats: TCTMemStats);

6
components/codetools/findoverloads.pas
View File

@ -33,8 +33,10 @@ unit FindOverloads;
interface
uses
Classes, SysUtils, FileProcs, BasicCodeTools, CodeTree, CodeGraph,
CodeCache, FindDeclarationTool, AVL_Tree, FindDeclarationCache, StdCodeTools;
Classes, SysUtils, Laz_AVL_Tree,
// Codetools
FileProcs, BasicCodeTools, CodeTree, CodeGraph,
CodeCache, FindDeclarationTool, FindDeclarationCache, StdCodeTools;
type
TOverloadsGraphEdge = class;

8
components/codetools/h2pastool.pas
View File

@ -94,10 +94,12 @@ unit H2PasTool;
interface
uses
Classes, SysUtils, CodeToolsStructs, AVL_Tree,
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
AvgLvlTree,
// Codetools
FileProcs, BasicCodeTools, CCodeParserTool,
NonPascalCodeTools, KeywordFuncLists, CodeCache,
CodeTree, CodeAtom;
NonPascalCodeTools, KeywordFuncLists, CodeCache, CodeTree, CodeAtom;
const
DefaultMaxPascalIdentLen = 70;

8
components/codetools/ide/addassignmethoddlg.pas
View File

@ -30,8 +30,12 @@ unit AddAssignMethodDlg;
interface
uses
Classes, SysUtils, FileUtil, LResources, Forms, Controls, Graphics,
Dialogs, ButtonPanel, StdCtrls, ComCtrls, Menus, AVL_Tree,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
LResources, Forms, Controls, Graphics,
Dialogs, ButtonPanel, StdCtrls, ComCtrls, Menus,
// LazUtils
FileUtil,
// Codetools
CodeCache, CodeToolManager, FileProcs, PascalParserTool,
BasicCodeTools, CodeTree, FindDeclarationTool,

14
components/codetools/ide/codyfindoverloads.pas
View File

@ -44,15 +44,17 @@ unit CodyFindOverloads;
interface
uses
Classes, SysUtils, AVL_Tree, contnrs,
Classes, SysUtils, contnrs, Laz_AVL_Tree,
// LazUtils
FileUtil, LazLoggerBase, LazUtilities,
Forms, Controls, Graphics,
Dialogs, ExtCtrls, StdCtrls, Grids, ComCtrls,
// LCL
Forms, Controls, Graphics, Dialogs, ExtCtrls, StdCtrls, Grids, ComCtrls,
// Codetools
CodeToolManager, CodeTree, CodeCache, FindDeclarationTool,
PascalParserTool, BasicCodeTools, CTUnitGraph, FileProcs, StdCodeTools,
CodeGraph,
LazIDEIntf, IDEWindowIntf, ProjectIntf,
CodyUtils, CodyStrConsts;
CodeGraph, CodyUtils, CodyStrConsts,
// IdeIntf
LazIDEIntf, IDEWindowIntf, ProjectIntf;
type
TCFOUnit = class(TUGUnit)

19
components/codetools/ide/codyidentifiersdlg.pas
View File

@ -38,13 +38,18 @@ unit CodyIdentifiersDlg;
interface
uses
Classes, SysUtils, LCLProc, avl_tree, contnrs, Forms,
Controls, Dialogs, ButtonPanel, StdCtrls, ExtCtrls, LCLType,
Buttons, Menus, PackageIntf, LazIDEIntf, SrcEditorIntf, ProjectIntf,
CompOptsIntf, IDEDialogs, IDEMsgIntf, IDEExternToolIntf, CodeCache,
BasicCodeTools, CustomCodeTool, CodeToolManager, UnitDictionary, CodeTree,
Classes, SysUtils, LCLProc, contnrs, Laz_AVL_Tree,
// LCL
Forms, Controls, Dialogs, ButtonPanel, StdCtrls, ExtCtrls, LCLType, Buttons, Menus,
// IdeIntf
PackageIntf, LazIDEIntf, SrcEditorIntf, ProjectIntf,
CompOptsIntf, IDEDialogs, IDEMsgIntf, IDEExternToolIntf,
// Codetools
CodeCache, BasicCodeTools, CustomCodeTool, CodeToolManager, UnitDictionary, CodeTree,
LinkScanner, DefineTemplates, CodeToolsStructs, FindDeclarationTool,
CodyStrConsts, CodyUtils, CodyOpts, FileProcs, LazFileUtils, LazFileCache;
CodyStrConsts, CodyUtils, CodyOpts, FileProcs,
// LazUtils
LazFileUtils, LazFileCache, AvgLvlTree;
const
PackageNameFPCSrcDir = 'FPCSrcDir';
@ -690,7 +695,7 @@ end;
procedure TCodyUnitDictionary.CheckFiles;
var
aFilename: String;
StrItem: PStringToStringTreeItem;
StrItem: PStringToStringItem;
List: TStringList;
UDGroup: TUDUnitGroup;
CurUnit: TUDUnit;

5
components/codetools/ide/codynodeinfodlg.pas
View File

@ -30,8 +30,9 @@ unit CodyNodeInfoDlg;
interface
uses
Classes, SysUtils, AVL_Tree, Forms, Controls, Graphics, Dialogs,
ButtonPanel, ComCtrls, StdCtrls,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
Forms, Controls, Graphics, Dialogs, ButtonPanel, ComCtrls, StdCtrls,
// IDEIntf
SrcEditorIntf,
// CodeTools

38
components/codetools/ide/ppulistdlg.pas
View File

@ -30,9 +30,11 @@ unit PPUListDlg;
interface
uses
Classes, SysUtils, contnrs, math, LCLProc, FileUtil, Forms,
Controls, Dialogs, ButtonPanel, Grids, StdCtrls, AvgLvlTree,
Classes, SysUtils, contnrs, math, Laz_AVL_Tree,
// LCL
LCLProc, FileUtil, Forms, Controls, Dialogs, ButtonPanel, Grids, StdCtrls,
ExtCtrls, ComCtrls,
AvgLvlTree,
// IDEIntf
ProjectIntf, LazIDEIntf, IDEDialogs, IDEWindowIntf,
PackageIntf,
@ -129,10 +131,10 @@ type
FMainItem: TPPUDlgListItem;
FProject: TLazProject;
FIdleConnected: boolean;
FSearchingItems: TAvgLvlTree; // tree of TPPUDlgListItem sorted for TheUnitName
FItems: TAvgLvlTree; // tree of TPPUDlgListItem sorted for TheUnitName
FSearchingItems: TAvlTree; // tree of TPPUDlgListItem sorted for TheUnitName
FItems: TAvlTree; // tree of TPPUDlgListItem sorted for TheUnitName
FSort: array[1..3] of TPPUListSortRec;
FDlgLinkedFiles: TAvgLvlTree; // tree of TPPUDlgLinkedFile sorted for ID, file, flags
FDlgLinkedFiles: TAvlTree; // tree of TPPUDlgLinkedFile sorted for ID, file, flags
procedure SetProject(const AValue: TLazProject);
procedure SetIdleConnected(const AValue: boolean);
@ -149,7 +151,7 @@ type
// units grid
procedure UpdateUnitsGrid;
function CompareUnits({%H-}Tree: TAvgLvlTree; Data1, Data2: Pointer): integer;
function CompareUnits({%H-}Tree: TAvlTree; Data1, Data2: Pointer): integer;
procedure JumpToUnit(TheUnitName: string);
// units info
@ -254,9 +256,9 @@ end;
procedure TPPUListDialog.FormCreate(Sender: TObject);
begin
FSearchingItems:=TAvgLvlTree.Create(@ComparePPUListItems);
FItems:=TAvgLvlTree.Create(@ComparePPUListItems);
FDlgLinkedFiles:=TAvgLvlTree.Create(@ComparePPULinkedFiles);
FSearchingItems:=TAvlTree.Create(@ComparePPUListItems);
FItems:=TAvlTree.Create(@ComparePPUListItems);
FDlgLinkedFiles:=TAvlTree.Create(@ComparePPULinkedFiles);
FSort[1].Category:=plsOSize;
FSort[2].Category:=plsName;
@ -562,17 +564,17 @@ procedure TPPUListDialog.UpdateUnitsGrid;
var
Grid: TStringGrid;
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Item: TPPUDlgListItem;
Row: Integer;
s: String;
TotalPPUBytes, TotalOBytes: int64;
SortedItems: TAvgLvlTree;
SortedItems: TAvlTree;
begin
Grid:=UnitsStringGrid;
Grid.BeginUpdate;
SortedItems:=TAvgLvlTree.CreateObjectCompare(@CompareUnits);
SortedItems:=TAvlTree.CreateObjectCompare(@CompareUnits);
try
Node:=FItems.FindLowest;
TotalPPUBytes:=0;
@ -679,7 +681,7 @@ begin
dec(Result);
end;
function TPPUListDialog.CompareUnits(Tree: TAvgLvlTree; Data1, Data2: Pointer
function TPPUListDialog.CompareUnits(Tree: TAvlTree; Data1, Data2: Pointer
): integer;
function CompareInt(const a,b: int64; Reverse: boolean): integer;
@ -838,7 +840,7 @@ function TPPUListDialog.FindUsesPath(UsingUnit, UsedUnit: TPPUDlgListItem): TFPL
Result is a list of TPPUDlgListItem
}
var
Visited: TAvgLvlTree;
Visited: TAvlTree;
function Search(Item: TPPUDlgListItem; Path: TFPList): boolean;
var
@ -864,7 +866,7 @@ var
begin
Result:=TFPList.Create;
if (UsingUnit=nil) or (UsedUnit=nil) then exit;
Visited:=TAvgLvlTree.Create(@ComparePPUListItems);
Visited:=TAvlTree.Create(@ComparePPUListItems);
try
if Search(UsedUnit,Result) then
Result.Add(UsedUnit);
@ -912,7 +914,7 @@ procedure TPPUListDialog.UpdateLinkedFilesTreeView;
end;
var
PPUNode, DlgLinkedFileNode: TAvgLvlTreeNode;
PPUNode, DlgLinkedFileNode: TAvlTreeNode;
Item: TPPUDlgListItem;
PPULinkedFile: TPPULinkedFile;
DlgLinkedFile: TPPUDlgLinkedFile;
@ -976,7 +978,7 @@ const
MaxNonIdleTime = (1/86400)/2;
var
StartTime: TDateTime;
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Item: TPPUDlgListItem;
AnUnitName: String;
InFilename: String;
@ -1130,7 +1132,7 @@ end;
function TPPUListDialog.FindUnit(AnUnitName: string): TPPUDlgListItem;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
begin
Node:=FItems.FindKey(Pointer(AnUnitName),@CompareUnitNameWithPPUListItem);
if Node=nil then

33
components/codetools/identcompletiontool.pas
View File

@ -48,12 +48,14 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, typinfo, FileProcs, LazFileUtils,
CodeTree, CodeAtom, CodeCache, CustomCodeTool, CodeToolsStrConsts,
KeywordFuncLists, BasicCodeTools, LinkScanner, AvgLvlTree, AVL_Tree,
SourceChanger, FindDeclarationTool, PascalReaderTool, PascalParserTool,
CodeToolsStructs, ExprEval, LazDbgLog, crc;
Classes, SysUtils, typinfo, crc, Laz_AVL_Tree,
// LazUtils
LazFileUtils, LazDbgLog, AvgLvlTree,
// Codetools
FileProcs, CodeTree, CodeAtom, CodeCache, CustomCodeTool, CodeToolsStrConsts,
KeywordFuncLists, BasicCodeTools, LinkScanner, SourceChanger,
FindDeclarationTool, PascalReaderTool, PascalParserTool, ExprEval;
type
TIdentCompletionTool = class;
TIdentifierHistoryList = class;
@ -236,13 +238,13 @@ type
FFilteredList: TFPList; // list of TIdentifierListItem
FFlags: TIdentifierListFlags;
FHistory: TIdentifierHistoryList;
FItems: TAvgLvlTree; // tree of TIdentifierListItem (completely sorted)
FItems: TAvlTree; // tree of TIdentifierListItem (completely sorted)
FIdentView: TAVLTree; // tree of TIdentifierListItem sorted for identifiers
FUsedTools: TAVLTree; // tree of TFindDeclarationTool
FIdentSearchItem: TIdentifierListSearchItem;
FPrefix: string;
FStartContext: TFindContext;
function CompareIdentListItems({%H-}Tree: TAvgLvlTree; Data1, Data2: Pointer): integer;
function CompareIdentListItems({%H-}Tree: TAvlTree; Data1, Data2: Pointer): integer;
procedure SetHistory(const AValue: TIdentifierHistoryList);
procedure SetSortForHistory(AValue: boolean);
procedure SetSortForScope(AValue: boolean);
@ -554,8 +556,7 @@ end;
{ TIdentifierList }
function TIdentifierList.CompareIdentListItems(Tree: TAvgLvlTree; Data1,
Data2: Pointer): integer;
function TIdentifierList.CompareIdentListItems(Tree: TAvlTree; Data1, Data2: Pointer): integer;
var
Item1: TIdentifierListItem absolute Data1;
Item2: TIdentifierListItem absolute Data2;
@ -610,7 +611,7 @@ end;
procedure TIdentifierList.UpdateFilteredList;
var
AnAVLNode: TAvgLvlTreeNode;
AnAVLNode: TAvlTreeNode;
CurItem: TIdentifierListItem;
begin
if not (ilfFilteredListNeedsUpdate in FFlags) then exit;
@ -676,7 +677,7 @@ end;
constructor TIdentifierList.Create;
begin
FFlags:=[ilfFilteredListNeedsUpdate];
FItems:=TAvgLvlTree.CreateObjectCompare(@CompareIdentListItems);
FItems:=TAvlTree.CreateObjectCompare(@CompareIdentListItems);
FIdentView:=TAVLTree.Create(@CompareIdentListItemsForIdents);
FIdentSearchItem:=TIdentifierListSearchItem.Create;
FCreatedIdentifiers:=TFPList.Create;
@ -868,7 +869,7 @@ function TIdentifierList.CompletePrefix(const OldPrefix: string): string;
// search all identifiers beginning with Prefix
// and return the biggest shared prefix of all of them
var
AnAVLNode: TAvgLvlTreeNode;
AnAVLNode: TAvlTreeNode;
CurItem: TIdentifierListItem;
FoundFirst: Boolean;
SamePos: Integer;
@ -909,7 +910,7 @@ function TIdentifierList.CalcMemSize: PtrUInt;
var
i: Integer;
Node: TAVLTreeNode;
AvgNode: TAvgLvlTreeNode;
AvgNode: TAvlTreeNode;
li: TIdentifierListItem;
hli: TIdentHistListItem;
begin
@ -929,7 +930,7 @@ begin
inc(Result,FHistory.CalcMemSize);
end;
if FItems<>nil then begin
{%H-}inc(Result,FItems.Count*SizeOf(TAvgLvlTreeNode));
{%H-}inc(Result,FItems.Count*SizeOf(TAvlTreeNode));
AvgNode:=FItems.FindLowest;
while AvgNode<>nil do begin
li:=TIdentifierListItem(AvgNode.Data);
@ -2505,7 +2506,7 @@ end;
procedure TIdentCompletionTool.AddCompilerDirectiveMacros(Directive: string);
var
Macros: TStringToStringTree;
StrItem: PStringToStringTreeItem;
StrItem: PStringToStringItem;
CodeBufs: TAVLTree;
AVLNode: TAVLTreeNode;

7
components/codetools/lfmtrees.pas
View File

@ -30,8 +30,11 @@ unit LFMTrees;
interface
uses
Classes, SysUtils, AVL_Tree, FileProcs, LazUtilities,
BasicCodeTools, CodeCache, TypInfo;
Classes, SysUtils, TypInfo, Laz_AVL_Tree,
// LazUtils
LazUtilities,
// Codetools
FileProcs, BasicCodeTools, CodeCache;
type
{ TLFMTreeNode }

2
components/codetools/linkscanner.pas
View File

@ -47,7 +47,7 @@ uses
MemCheck,
{$ENDIF}
// RTL + FCL
Classes, SysUtils, math, AVL_Tree,
Classes, SysUtils, math, Laz_AVL_Tree,
// CodeTools
CodeToolsStrConsts, CodeToolMemManager, FileProcs, ExprEval, SourceLog,
KeywordFuncLists, BasicCodeTools,

9
components/codetools/methodjumptool.pas
View File

@ -40,9 +40,12 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, FileProcs, LazFileUtils, CodeTree, PascalParserTool,
StdCodeTools, KeywordFuncLists, BasicCodeTools,
LinkScanner, CodeCache, PascalReaderTool, AVL_Tree;
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
LazFileUtils,
// Codetools
FileProcs, CodeTree, PascalParserTool, StdCodeTools, KeywordFuncLists,
BasicCodeTools, LinkScanner, CodeCache, PascalReaderTool;
type

2
components/codetools/nonpascalcodetools.pas
View File

@ -31,7 +31,7 @@ unit NonPascalCodeTools;
interface
uses
Classes, SysUtils, AVL_Tree, KeywordFuncLists, FileProcs;
SysUtils, KeywordFuncLists, FileProcs;
// C
function CompareCIdentifiers(Identifier1, Identifier2: PChar): integer;

7
components/codetools/pascalparsertool.pas
View File

@ -42,9 +42,10 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, FileProcs, CodeToolsStrConsts, CodeTree, CodeAtom, ExprEval,
CustomCodeTool, MultiKeyWordListTool, KeywordFuncLists,
CodeToolsStructs, LinkScanner, CodeCache, AVL_Tree;
Classes, SysUtils,
// Codetools
FileProcs, CodeToolsStrConsts, CodeTree, CodeAtom, ExprEval,
MultiKeyWordListTool, KeywordFuncLists, CodeToolsStructs, LinkScanner, CodeCache;
type
TProcHeadAttribute = (

9
components/codetools/pascalreadertool.pas
View File

@ -37,9 +37,12 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, FileProcs, CodeToolsStrConsts, CodeTree, CodeCache,
CodeAtom, CustomCodeTool, PascalParserTool, KeywordFuncLists, BasicCodeTools,
LinkScanner, AVL_Tree, LazFileUtils, LazDbgLog;
Classes, SysUtils,
// LazUtils
LazFileUtils, LazDbgLog,
// Codetools
FileProcs, CodeToolsStrConsts, CodeTree, CodeCache, CodeAtom,
PascalParserTool, KeywordFuncLists, BasicCodeTools, LinkScanner;
type
TPascalHintModifier = (

7
components/codetools/ppugraph.pas
View File

@ -30,12 +30,13 @@ unit PPUGraph;
interface
uses
Classes, SysUtils,
Classes, SysUtils, Laz_AVL_Tree,
{$IFnDEF HASAMIGA}
dynlibs,
{$ENDIF}
PPUParser, CodeTree, AVL_Tree, FileProcs,
LazFileUtils, BasicCodeTools, CodeGraph, CodeToolManager, CodeToolsStructs;
// Codetools
PPUParser, CodeTree, FileProcs, LazFileUtils, BasicCodeTools, CodeGraph,
CodeToolManager, CodeToolsStructs;
const
FPCPPUGroupPrefix = 'fpc_';

21
components/codetools/sourcechanger.pas
View File

@ -42,8 +42,12 @@ interface
{off $DEFINE VerboseSrcChanger}
uses
Classes, SysUtils, FileProcs, CodeToolsStrConsts, CodeCache, BasicCodeTools,
typinfo, LinkScanner, AVL_Tree, KeywordFuncLists, LazDbgLog;
Classes, SysUtils, typinfo, Laz_AVL_Tree,
// LazUtils
LazDbgLog,
// Codetools
FileProcs, CodeToolsStrConsts, CodeCache, BasicCodeTools, LinkScanner,
KeywordFuncLists;
type
// Insert policy types for class parts (properties, variables, method defs)
@ -844,8 +848,7 @@ begin
Result:=true;
end;
function TSourceChangeCache.IndentLine(LineStartPos, IndentDiff: integer
): boolean;
function TSourceChangeCache.IndentLine(LineStartPos, IndentDiff: integer): boolean;
var
OldIndent: LongInt;
NewIndent: Integer;
@ -906,18 +909,8 @@ begin
end;
procedure TSourceChangeCache.ConsistencyCheck;
{$IF FPC_FULLVERSION<30101}
var
CurResult: LongInt;
{$ENDIF}
begin
{$IF FPC_FULLVERSION<30101}
CurResult:=FEntries.ConsistencyCheck;
if CurResult<>0 then
RaiseCatchableException(IntToStr(CurResult));
{$ELSE}
FEntries.ConsistencyCheck;
{$ENDIF}
BeautifyCodeOptions.ConsistencyCheck;
end;

9
components/codetools/stdcodetools.pas
View File

@ -50,11 +50,14 @@ uses
{$IFDEF MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, TypInfo, CodeToolsStrConsts, FileProcs, CodeTree, CodeAtom,
Classes, SysUtils, TypInfo, Laz_AVL_Tree,
// Codetools
CodeToolsStrConsts, FileProcs, CodeTree, CodeAtom,
FindDeclarationTool, IdentCompletionTool, PascalReaderTool, PascalParserTool,
ExprEval, KeywordFuncLists, BasicCodeTools, LinkScanner,
CodeCache, AVL_Tree, LFMTrees, SourceChanger,
CustomCodeTool, CodeToolsStructs, LazFileUtils, LazFileCache;
CodeCache, LFMTrees, SourceChanger, CustomCodeTool, CodeToolsStructs,
// LazUtils
LazFileUtils, LazFileCache, AvgLvlTree;
type
TStandardCodeTool = class;

29
components/codetools/unitdictionary.pas
View File

@ -30,8 +30,12 @@ unit UnitDictionary;
interface
uses
Classes, SysUtils, AVL_Tree, BasicCodeTools, FileProcs, LazFileUtils,
CodeToolsStructs, FindDeclarationCache, CodeToolManager, CodeCache;
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
LazFileUtils, AvgLvlTree,
// Codetools
BasicCodeTools, FileProcs, CodeToolsStructs, FindDeclarationCache,
CodeToolManager, CodeCache;
const
// Version 2: added unit and group use count
@ -396,21 +400,10 @@ begin
if UnitsByFilename.Count<>UnitsByName.Count then
e('UnitsByFilename.Count<>UnitsByName.Count');
{$IF FPC_FULLVERSION<30101}
if UnitGroupsByFilename.ConsistencyCheck<>0 then
e('UnitGroupsByFilename.ConsistencyCheck<>0');
if UnitGroupsByName.ConsistencyCheck<>0 then
e('UnitGroupsByName.ConsistencyCheck<>0');
if UnitsByName.ConsistencyCheck<>0 then
e('UnitsByName.ConsistencyCheck<>0');
if UnitsByFilename.ConsistencyCheck<>0 then
e('UnitsByFilename.ConsistencyCheck<>0');
{$ELSE}
UnitGroupsByFilename.ConsistencyCheck;
UnitGroupsByName.ConsistencyCheck;
UnitsByName.ConsistencyCheck;
UnitsByFilename.ConsistencyCheck;
{$ENDIF}
IdentifiersCount:=0;
// check UnitsByName
@ -426,12 +419,7 @@ begin
e('unit '+CurUnit.Name+' in FUnitsByName not in FUnitsByFilename');
if CurUnit.Groups.Count=0 then
e('unit '+CurUnit.Name+' has not group');
{$IF FPC_FULLVERSION<30101}
if CurUnit.Groups.ConsistencyCheck<>0 then
e('unit '+CurUnit.Name+' UnitGroups.ConsistencyCheck<>0');
{$ELSE}
CurUnit.Groups.ConsistencyCheck;
{$ENDIF}
if (LastUnit<>nil)
and (CompareFilenames(LastUnit.Filename,CurUnit.Filename)=0) then
e('unit '+CurUnit.Name+' exists twice: '+CurUnit.Filename);
@ -491,12 +479,7 @@ begin
e('group '+Group.Name+' without filename');
if AVLFindPointer(FUnitGroupsByFilename,Group)=nil then
e('group '+Group.Name+' in FUnitGroupsByName not in FUnitGroupsByFilename');
{$IF FPC_FULLVERSION<30101}
if Group.Units.ConsistencyCheck<>0 then
e('group '+Group.Name+' Group.Units.ConsistencyCheck<>0');
{$ELSE}
Group.Units.ConsistencyCheck;
{$ENDIF}
if (LastGroup<>nil)
and (CompareFilenames(LastGroup.Filename,Group.Filename)=0) then
e('group '+Group.Name+' exists twice: '+Group.Filename);

15
components/education/educomppalette.pas
View File

@ -18,10 +18,15 @@ unit EduCompPalette;
interface
uses
Classes, SysUtils, LCLProc, FileUtil, LResources, Forms, Controls, Graphics,
Dialogs, ComCtrls, ExtCtrls, StdCtrls, AvgLvlTree,
FormEditingIntf, LazConfigStorage, IDEOptionsIntf, ComponentReg,
IDEImagesIntf, LazIDEIntf, LCLType,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
LCLProc, LCLType, LResources, Forms, Controls, Graphics, Dialogs, ComCtrls,
ExtCtrls, StdCtrls,
// LazUtils
LazConfigStorage, AvgLvlTree,
// IdeIntf
FormEditingIntf, IDEOptionsIntf, ComponentReg, IDEImagesIntf,
// Education
EduOptions;
type
@ -442,7 +447,7 @@ end;
function TEduComponentPaletteOptions.Save(Config: TConfigStorage): TModalResult;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Item: PStringToStringItem;
Cnt: Integer;
begin

13
components/education/edumenu.pas
View File

@ -18,9 +18,14 @@ unit EduMenu;
interface
uses
Classes, SysUtils, LCLProc, FileUtil, LResources, Forms, StdCtrls, ComCtrls,
AvgLvlTree, Controls, ExtCtrls,
LazConfigStorage, IDEOptionsIntf, MenuIntf, IDEImagesIntf, LazIDEIntf,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
LCLProc, LResources, Forms, StdCtrls, ComCtrls, Controls, ExtCtrls,
// LazUtils
AvgLvlTree, LazConfigStorage,
// IdeIntf
IDEOptionsIntf, MenuIntf, IDEImagesIntf,
// Education
EduOptions;
type
@ -367,7 +372,7 @@ end;
function TEduMenuOptions.Save(Config: TConfigStorage): TModalResult;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Item: PStringToStringItem;
Cnt: Integer;
begin

15
components/education/eduspeedbuttons.pas
View File

@ -18,9 +18,16 @@ unit EduSpeedButtons;
interface
uses
Classes, SysUtils, Controls, Graphics, LResources, Forms, StdCtrls, ExtCtrls,
LazConfigStorage, ComCtrls, Buttons, IDEOptionsIntf, EduOptions,
ObjectInspector, LazIDEIntf, IDEImagesIntf, Dialogs, AvgLvlTree;
Classes, SysUtils, Laz_AVL_Tree,
// LCL
Controls, Graphics, LResources, Forms, StdCtrls, ExtCtrls, Dialogs,
ComCtrls, Buttons,
// LazUtils
LazConfigStorage, AvgLvlTree,
// IdeIntf
IDEOptionsIntf, LazIDEIntf, IDEImagesIntf,
// Education
EduOptions;
type
@ -139,7 +146,7 @@ end;
function TEduSpeedButtonsOptions.Save(Config: TConfigStorage): TModalResult;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Item: PStringToStringItem;
Cnt: Integer;
begin

2
components/ideintf/componentreg.pas
View File

@ -24,7 +24,7 @@ unit ComponentReg;
interface
uses
Classes, SysUtils, typinfo, AVL_Tree, fgl,
Classes, SysUtils, typinfo, Laz_AVL_Tree, fgl,
{$IFDEF CustomIDEComps}
CustomIDEComps,
{$ENDIF}

18
components/ideintf/componenttreeview.pas
View File

@ -24,8 +24,10 @@ unit ComponentTreeView;
interface
uses
Classes, SysUtils, TypInfo, LCLProc, AvgLvlTree, Dialogs, Controls, ComCtrls,
Graphics, ExtCtrls,
Classes, SysUtils, TypInfo, Laz_AVL_Tree,
// LCL
LCLProc, Dialogs, Controls, ComCtrls, Graphics,
// IdeIntf
ObjInspStrConsts, PropEdits, PropEditUtils;
type
@ -100,14 +102,14 @@ type
TComponentWalker = class
FComponentTV: TComponentTreeView;
FCandidates: TAvgLvlTree;
FCandidates: TAvlTree;
FLookupRoot: TComponent;
FNode: TTreeNode;
protected
procedure GetOwnedPersistents(AComponent: TComponent; AProc: TGetPersistentProc);
public
constructor Create(
ATreeView: TComponentTreeView; ACandidates: TAvgLvlTree;
ATreeView: TComponentTreeView; ACandidates: TAvlTree;
ALookupRoot: TComponent; ANode: TTreeNode);
procedure Walk(AComponent: TComponent);
@ -161,7 +163,7 @@ begin
end;
constructor TComponentWalker.Create(ATreeView: TComponentTreeView;
ACandidates: TAvgLvlTree; ALookupRoot: TComponent; ANode: TTreeNode);
ACandidates: TAvlTree; ALookupRoot: TComponent; ANode: TTreeNode);
begin
{$IFDEF VerboseComponentTVWalker}
debugln(['TComponentWalker.Create ALookupRoot=',DbgSName(ALookupRoot)]);
@ -176,7 +178,7 @@ procedure TComponentWalker.Walk(AComponent: TComponent);
var
OldNode: TTreeNode;
Candidate: TComponentCandidate;
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
Root: TComponent;
begin
if csDestroying in AComponent.ComponentState then exit;
@ -617,7 +619,7 @@ end;
procedure TComponentTreeView.RebuildComponentNodes;
var
Candidates: TAvgLvlTree; // tree of TComponentCandidate sorted for aPersistent (CompareComponentCandidates)
Candidates: TAvlTree; // tree of TComponentCandidate sorted for aPersistent (CompareComponentCandidates)
RootObject: TPersistent;
RootComponent: TComponent absolute RootObject;
@ -684,7 +686,7 @@ begin
RootObject:=nil;
if RootObject <> nil then
begin
Candidates:=TAvgLvlTree.Create(TListSortCompare(@CompareComponentCandidates));
Candidates:=TAvlTree.Create(TListSortCompare(@CompareComponentCandidates));
try
// first add the lookup root
RootNode := Items.Add(nil, CreateNodeCaption(RootObject));

31
components/ideintf/ideexterntoolintf.pas
View File

@ -14,8 +14,13 @@ unit IDEExternToolIntf;
interface
uses
Classes, SysUtils, Math, TypInfo, UTF8Process, AvgLvlTree,
ObjInspStrConsts, LazLogger, LazFileUtils, LazFileCache, Menus, LCLProc;
Classes, SysUtils, Math, Laz_AVL_Tree,
// LCL
LCLProc,
// LazUtils
UTF8Process, LazFileUtils, LazFileCache,
// IdeIntf
ObjInspStrConsts, LazLogger, Menus;
const
SubToolFPC = 'FPC';
@ -188,11 +193,11 @@ type
FMaxLine: integer;
FMinLine: integer;
protected
FTree: TAvgLvlTree;
FCurrent: TAvgLvlTreeNode;
FTree: TAvlTree;
FCurrent: TAvlTreeNode;
function GetCurrent: TMessageLine; inline;
public
constructor Create(Tree: TAvgLvlTree; const aFilename: string;
constructor Create(Tree: TAvlTree; const aFilename: string;
aMinLine, aMaxLine: integer);
function GetEnumerator: TMessageLineEnumerator;
function MoveNext: boolean;
@ -215,10 +220,10 @@ type
FMessageLineClass: TMessageLineClass;
FOnMarksFixed: TETMarksFixedEvent;
FOwner: TObject;
FSortedForSrcPos: TAvgLvlTree; // tree of TMessageLine sorted for Filename, Line, Column, OutputIndex, Index
FSortedForSrcPos: TAvlTree; // tree of TMessageLine sorted for Filename, Line, Column, OutputIndex, Index
FUpdateSortedSrcPos: boolean;
fChangedHandler: TMethodList;
fMarkedFixed: TAvgLvlTree; // list of TMessageLine
fMarkedFixed: TAvlTree; // list of TMessageLine
function GetItems(Index: integer): TMessageLine;
procedure SetBaseDirectory(const AValue: string);
procedure LineChanged(Line: TMessageLine);
@ -1009,7 +1014,7 @@ begin
Result:=TMessageLine(FCurrent.Data);
end;
constructor TMessageLineEnumerator.Create(Tree: TAvgLvlTree;
constructor TMessageLineEnumerator.Create(Tree: TAvlTree;
const aFilename: string; aMinLine, aMaxLine: integer);
begin
FTree:=Tree;
@ -1637,7 +1642,7 @@ begin
InitCriticalSection(FCritSec);
FMessageLineClass:=aMsgLineClass;
fItems:=TFPList.Create;
FSortedForSrcPos:=TAvgLvlTree.Create(@CompareMsgLinesSrcPos);
FSortedForSrcPos:=TAvlTree.Create(@CompareMsgLinesSrcPos);
FUpdateSortedSrcPos:=true;
fChangedHandler:=TMethodList.Create;
end;
@ -1752,14 +1757,14 @@ procedure TMessageLines.MarkFixed(MsgLine: TMessageLine);
begin
//debugln(['TMessageLines.MarkFixed ',MsgLine.Msg,' ',MsgLine.Line,',',MsgLine.Column]);
if fMarkedFixed=nil then
fMarkedFixed:=TAvgLvlTree.Create;
fMarkedFixed:=TAvlTree.Create;
if fMarkedFixed.Find(MsgLine)=nil then
fMarkedFixed.Add(MsgLine);
end;
procedure TMessageLines.ApplyFixedMarks;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Msg: TMessageLine;
List: TFPList;
begin
@ -1810,7 +1815,7 @@ procedure TMessageLines.SourceLinesInserted(Filename: string; Line,
// adjust Line numbers in all messages
var
CmpLine: TMessageLine;
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
MsgLine: TMessageLine;
begin
if (Filename='') or (Count<=0) then exit;
@ -1842,7 +1847,7 @@ procedure TMessageLines.SourceLinesDeleted(Filename: string; FirstLine,
// adjust Line numbers in all messages and mark lines in range as deleted
var
CmpLine: TMessageLine;
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
MsgLine: TMessageLine;
begin
if (Filename='') or (Count<=0) then exit;

68
components/lazcontrols/lvlgraphctrl.pas
View File

@ -15,10 +15,12 @@ unit LvlGraphCtrl;
interface
uses
Classes, SysUtils, types, math, typinfo,
FPimage, FPCanvas,
AvgLvlTree, LazLoggerBase, LMessages, LCLType, LResources,
GraphType, GraphMath, Graphics, Controls, ImgList, LCLIntf, Forms, Themes;
Classes, SysUtils, types, math, typinfo, FPimage, FPCanvas, Laz_AVL_Tree,
// LazUtils
LazLoggerBase, AvgLvlTree,
// LCL
LMessages, LCLType, LCLIntf, GraphType, GraphMath, Graphics, Controls, ImgList,
Forms, Themes;
type
TLazCtrlPalette = array of TFPColor;
@ -93,9 +95,9 @@ type
function OutEdgeCount: integer;
property OutEdges[Index: integer]: TLvlGraphEdge read GetOutEdges;
function GetVisibleSourceNodes: TLvlGraphNodeArray;
function GetVisibleSourceNodesAsAVLTree: TAvgLvlTree;
function GetVisibleSourceNodesAsAVLTree: TAvlTree;
function GetVisibleTargetNodes: TLvlGraphNodeArray;
function GetVisibleTargetNodesAsAVLTree: TAvgLvlTree;
function GetVisibleTargetNodesAsAVLTree: TAvlTree;
property IndexInLevel: integer read GetIndexInLevel write SetIndexInLevel;
property Level: TLvlGraphLevel read FLevel write SetLevel;
property Selected: boolean read FSelected write SetSelected;
@ -136,9 +138,9 @@ type
property Highlighted: boolean read FHighlighted write SetHighlighted;
property DrawnAt: TRect read FDrawnAt; // last drawn with scrolling
function GetVisibleSourceNodes: TLvlGraphNodeArray;
function GetVisibleSourceNodesAsAVLTree: TAvgLvlTree;
function GetVisibleSourceNodesAsAVLTree: TAvlTree;
function GetVisibleTargetNodes: TLvlGraphNodeArray;
function GetVisibleTargetNodesAsAVLTree: TAvgLvlTree;
function GetVisibleTargetNodesAsAVLTree: TAvlTree;
function AsString: string;
end;
TLvlGraphEdgeClass = class of TLvlGraphEdge;
@ -595,10 +597,10 @@ function GetDistancePointPoint(X1,Y1,X2,Y2: integer): integer;
// level graph
procedure LvlGraphMinimizeCrossings(Graph: TLvlGraph); overload;
procedure LvlGraphHighlightNode(Node: TLvlGraphNode;
HighlightedElements: TAvgLvlTree; FollowIn, FollowOut: boolean);
HighlightedElements: TAvlTree; FollowIn, FollowOut: boolean);
function CompareLGNodesByCenterPos(Node1, Node2: Pointer): integer;
procedure DrawCurvedLvlLeftToRightEdge(Canvas: TFPCustomCanvas; x1, y1, x2, y2: integer);
function NodeAVLTreeToNodeArray(Nodes: TAvgLvlTree; RemoveHidden: boolean; FreeTree: boolean): TLvlGraphNodeArray;
function NodeAVLTreeToNodeArray(Nodes: TAvlTree; RemoveHidden: boolean; FreeTree: boolean): TLvlGraphNodeArray;
function NodeArrayAsString(Nodes: TLvlGraphNodeArray): String;
// debugging
@ -717,7 +719,7 @@ begin
end;
end;
procedure LvlGraphHighlightNode(Node: TLvlGraphNode; HighlightedElements: TAvgLvlTree;
procedure LvlGraphHighlightNode(Node: TLvlGraphNode; HighlightedElements: TAvlTree;
FollowIn, FollowOut: boolean);
var
i: Integer;
@ -927,10 +929,10 @@ begin
Freemem(Points);
end;
function NodeAVLTreeToNodeArray(Nodes: TAvgLvlTree; RemoveHidden: boolean;
function NodeAVLTreeToNodeArray(Nodes: TAvlTree; RemoveHidden: boolean;
FreeTree: boolean): TLvlGraphNodeArray;
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
Node: TLvlGraphNode;
i: Integer;
begin
@ -1550,7 +1552,7 @@ var
e: Integer;
OtherNode: TMinXNode;
k: Integer;
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
P2PItem: PPointerToPointerItem;
begin
AVLNode:=FGraphNodeToNode.Tree.FindLowest;
@ -2568,11 +2570,11 @@ var
n: Integer;
CurNode: TLvlGraphNode;
e: Integer;
HighlightedElements: TAvgLvlTree;
HighlightedElements: TAvlTree;
Edge: TLvlGraphEdge;
begin
BeginUpdate;
HighlightedElements:=TAvgLvlTree.Create;
HighlightedElements:=TAvlTree.Create;
try
if Element is TLvlGraphNode then
LvlGraphHighlightNode(TLvlGraphNode(Element),HighlightedElements,true,true)
@ -3062,7 +3064,7 @@ end;
procedure TLvlGraph.CreateTopologicalLevels(HighLevels: boolean);
{$DEFINE LvlGraphConsistencyCheck}
var
ExtNodes: TAvgLvlTree; // tree of TGraphLevelerNode sorted by Node
ExtNodes: TAvlTree; // tree of TGraphLevelerNode sorted by Node
MaxLevel: Integer;
function GetExtNode(Node: TLvlGraphNode): TGraphLevelerNode;
@ -3117,7 +3119,7 @@ begin
{$IFDEF LvlGraphConsistencyCheck}
ConsistencyCheck(false);
{$ENDIF}
ExtNodes:=TAvgLvlTree.Create(@CompareGraphLevelerNodes);
ExtNodes:=TAvlTree.Create(@CompareGraphLevelerNodes);
try
// init ExtNodes
// clear BackEdge flags
@ -3181,7 +3183,7 @@ var
l: Integer;
LastNode: TLvlGraphNode;
NextNode: TLvlGraphNode;
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
P2PItem: PPointerToPointerItem;
MergeAtSourceNode: Boolean;
SourceInfo: PNodeInfo;
@ -3573,10 +3575,10 @@ begin
Result:=NodeAVLTreeToNodeArray(GetVisibleSourceNodesAsAVLTree,true,true);
end;
function TLvlGraphEdge.GetVisibleSourceNodesAsAVLTree: TAvgLvlTree;
function TLvlGraphEdge.GetVisibleSourceNodesAsAVLTree: TAvlTree;
// return all visible nodes connected in Source direction
var
Visited: TAvgLvlTree;
Visited: TAvlTree;
procedure Search(Node: TLvlGraphNode);
var
@ -3594,8 +3596,8 @@ var
end;
begin
Result:=TAvgLvlTree.Create;
Visited:=TAvgLvlTree.Create;
Result:=TAvlTree.Create;
Visited:=TAvlTree.Create;
try
Search(Source);
finally
@ -3609,10 +3611,10 @@ begin
Result:=NodeAVLTreeToNodeArray(GetVisibleTargetNodesAsAVLTree,true,true);
end;
function TLvlGraphEdge.GetVisibleTargetNodesAsAVLTree: TAvgLvlTree;
function TLvlGraphEdge.GetVisibleTargetNodesAsAVLTree: TAvlTree;
// return all visible nodes connected in Target direction
var
Visited: TAvgLvlTree;
Visited: TAvlTree;
procedure Search(Node: TLvlGraphNode);
var
@ -3630,8 +3632,8 @@ var
end;
begin
Result:=TAvgLvlTree.Create;
Visited:=TAvgLvlTree.Create;
Result:=TAvlTree.Create;
Visited:=TAvlTree.Create;
try
Search(Source);
finally
@ -3893,7 +3895,7 @@ begin
Result:=NodeAVLTreeToNodeArray(GetVisibleSourceNodesAsAVLTree,true,true);
end;
function TLvlGraphNode.GetVisibleSourceNodesAsAVLTree: TAvgLvlTree;
function TLvlGraphNode.GetVisibleSourceNodesAsAVLTree: TAvlTree;
// return all visible nodes connected in Source direction
procedure Search(Node: TLvlGraphNode);
@ -3912,7 +3914,7 @@ function TLvlGraphNode.GetVisibleSourceNodesAsAVLTree: TAvgLvlTree;
var
i: Integer;
begin
Result:=TAvgLvlTree.Create;
Result:=TAvlTree.Create;
for i:=0 to InEdgeCount-1 do
Search(InEdges[i].Source);
end;
@ -3923,10 +3925,10 @@ begin
Result:=NodeAVLTreeToNodeArray(GetVisibleTargetNodesAsAVLTree,true,true);
end;
function TLvlGraphNode.GetVisibleTargetNodesAsAVLTree: TAvgLvlTree;
function TLvlGraphNode.GetVisibleTargetNodesAsAVLTree: TAvlTree;
// return all visible nodes connected in Target direction
var
Visited: TAvgLvlTree;
Visited: TAvlTree;
procedure Search(Node: TLvlGraphNode);
var
@ -3946,8 +3948,8 @@ var
var
i: Integer;
begin
Result:=TAvgLvlTree.Create;
Visited:=TAvgLvlTree.Create;
Result:=TAvlTree.Create;
Visited:=TAvlTree.Create;
try
for i:=0 to OutEdgeCount-1 do
Search(OutEdges[i].Target);

1668
components/lazutils/avglvltree.pas
View File

File diff suppressed because it is too large Load Diff

17
components/lazutils/easylazfreetype.pas
View File

@ -25,7 +25,9 @@ unit EasyLazFreeType;
interface
uses
Classes, SysUtils, LazFreeType, TTTypes, TTRASTER, AvgLvlTree, fpimage, Types, lazutf8;
Classes, SysUtils, fpimage, Laz_AVL_Tree,
// LazUtils // Note: Types must be after TTTypes for PByte.
LazUTF8, LazFreeType, TTRASTER, TTTypes, Types;
type
TGlyphRenderQuality = (grqMonochrome, grqLowQuality, grqHighQuality);
@ -229,7 +231,7 @@ type
FClearType: boolean;
FNamesArray: array of string;
FCollection: TCustomFreeTypeFontCollection;
function FindGlyphNode(Index: Integer): TAvgLvlTreeNode;
function FindGlyphNode(Index: Integer): TAvlTreeNode;
function GetCharIndex(AUnicodeChar: integer): integer;
function GetDPI: integer;
function GetFamily: string;
@ -265,7 +267,7 @@ type
FFaceLoaded: boolean;
FInstance: TT_Instance;
FInstanceCreated : boolean;
FGlyphTable: TAvgLvlTree;
FGlyphTable: TAvlTree;
FCharMap: TT_CharMap;
FCharmapOk, FCharmapSymbol: boolean;
FAscentValue, FDescentValue, FLineGapValue, FLargeLineGapValue, FCapHeight: single;
@ -920,7 +922,7 @@ begin
if (a[i] = 'Italic') or (a[i] = 'Oblique') then result += [ftsItalic];
end;
function TFreeTypeFont.FindGlyphNode(Index: Integer): TAvgLvlTreeNode;
function TFreeTypeFont.FindGlyphNode(Index: Integer): TAvlTreeNode;
var DataValue: integer;
begin
Result:=FGlyphTable.Root;
@ -977,8 +979,9 @@ begin
end;
function TFreeTypeFont.GetGlyph(Index: integer): TFreeTypeGlyph;
var node: TAvgLvlTreeNode;
lGlyph: TFreeTypeGlyph;
var
node: TAvlTreeNode;
lGlyph: TFreeTypeGlyph;
begin
if not CheckInstance then
begin
@ -1433,7 +1436,7 @@ begin
FCharmapOk := false;
FPointSize := 10;
FDPI := 96;
FGlyphTable := TAvgLvlTree.Create;
FGlyphTable := TAvlTree.Create;
FHinted := true;
FWidthFactor := 1;
FClearType := false;

1515
components/lazutils/laz_avl_tree.pp Normal file
View File

File diff suppressed because it is too large Load Diff

18
components/lazutils/lazconfigstorage.pas
View File

@ -18,7 +18,9 @@ unit LazConfigStorage;
interface
uses
Classes, SysUtils, typinfo, AvgLvlTree, LazLogger;
Classes, SysUtils, typinfo, Laz_AVL_Tree,
// LazUtils
LazLogger, AvgLvlTree;
type
{ TConfigStorage }
@ -93,7 +95,7 @@ type
Name: string;
Value: string;
Parent: TConfigMemStorageNode;
Children: TAvgLvlTree; // tree of TConfigMemStorageNode
Children: TAvlTree; // tree of TConfigMemStorageNode
procedure ClearChilds;
constructor Create(AParent: TConfigMemStorageNode; const AName: string);
destructor Destroy; override;
@ -173,7 +175,7 @@ end;
procedure SaveStringToStringTree(Config: TConfigStorage; const Path: string;
Tree: TStringToStringTree);
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Item: PStringToStringItem;
i: Integer;
SubPath: String;
@ -709,7 +711,7 @@ end;
procedure TConfigMemStorage.CreateChilds(Node: TConfigMemStorageNode);
begin
Node.Children:=TAvgLvlTree.Create(@CompareConfigMemStorageNodes);
Node.Children:=TAvlTree.Create(@CompareConfigMemStorageNodes);
end;
procedure TConfigMemStorage.Modify(const APath: string;
@ -718,7 +720,7 @@ var
Node: TConfigMemStorageNode;
p: PChar;
StartPos: PChar;
ChildNode: TAvgLvlTreeNode;
ChildNode: TAvlTreeNode;
Child: TConfigMemStorageNode;
NewName: string;
begin
@ -912,7 +914,7 @@ procedure TConfigMemStorage.SaveToConfig(Config: TConfigStorage;
procedure Save(Node: TConfigMemStorageNode; SubPath: string);
var
ChildNode: TAvgLvlTreeNode;
ChildNode: TAvlTreeNode;
Child: TConfigMemStorageNode;
Names: String;
begin
@ -996,7 +998,7 @@ procedure TConfigMemStorage.WriteDebugReport;
procedure w(Node: TConfigMemStorageNode; Prefix: string);
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
begin
if Node=nil then exit;
DebugLn(['TConfigMemStorage.WriteDebugReport ',Prefix,'Name="',Node.Name,'" Value="',Node.Value,'"']);
@ -1018,7 +1020,7 @@ end;
procedure TConfigMemStorageNode.ClearChilds;
var
OldChilds: TAvgLvlTree;
OldChilds: TAvlTree;
begin
if Children<>nil then begin
OldChilds:=Children;

3
components/lazutils/lazfilecache.pas
View File

@ -13,7 +13,8 @@ unit LazFileCache;
interface
uses
Classes, SysUtils, LazDbgLog, AVL_Tree, LazFileUtils;
Classes, SysUtils, Laz_AVL_Tree,
LazDbgLog, LazFileUtils;
type
TFileStateCacheItemFlag = (

50
components/lazutils/lazfreetypefontcollection.pas
View File

@ -13,7 +13,9 @@ unit LazFreeTypeFontCollection;
interface
uses
Classes, SysUtils, EasyLazFreeType, AvgLvlTree, LazFreeType, TTTypes;
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
EasyLazFreeType, LazFreeType, TTTypes;
type
{ TFontCollectionItem }
@ -94,18 +96,18 @@ type
TFreeTypeFontCollection = class(TCustomFreeTypeFontCollection)
private
FFontList: TAvgLvlTree;
FFontList: TAvlTree;
FTempFont: TFreeTypeFont;
FUpdateCount: integer;
FFamilyList: TAvgLvlTree;
FFamilyList: TAvlTree;
function AddFamily(AName: string): TFamilyCollectionItem;
function FindFamily(AName: string): TFamilyCollectionItem;
function FindFont(AFileName: string): TFontCollectionItem;
function CompareFontFileName({%H-}Tree: TAvgLvlTree; Data1, Data2: Pointer): integer;
function CompareFamilyName({%H-}Tree: TAvgLvlTree; Data1, Data2: Pointer): integer;
function CompareFontFileName({%H-}Tree: TAvlTree; Data1, Data2: Pointer): integer;
function CompareFamilyName({%H-}Tree: TAvlTree; Data1, Data2: Pointer): integer;
protected
function GetFont(AFileName: string): TCustomFontCollectionItem; override;
@ -146,9 +148,9 @@ type
TFamilyEnumerator = class(TInterfacedObject,IFreeTypeFamilyEnumerator)
private
FNodeEnumerator: TAvgLvlTreeNodeEnumerator;
FNodeEnumerator: TAvlTreeNodeEnumerator;
public
constructor Create(ANodeEnumerator: TAvgLvlTreeNodeEnumerator);
constructor Create(ANodeEnumerator: TAvlTreeNodeEnumerator);
destructor Destroy; override;
function MoveNext: boolean;
function GetCurrent: TCustomFamilyCollectionItem;
@ -158,9 +160,9 @@ type
TFontEnumerator = class(TInterfacedObject,IFreeTypeFontEnumerator)
private
FNodeEnumerator: TAvgLvlTreeNodeEnumerator;
FNodeEnumerator: TAvlTreeNodeEnumerator;
public
constructor Create(ANodeEnumerator: TAvgLvlTreeNodeEnumerator);
constructor Create(ANodeEnumerator: TAvlTreeNodeEnumerator);
destructor Destroy; override;
function MoveNext: boolean;
function GetCurrent: TCustomFontCollectionItem;
@ -391,7 +393,7 @@ begin
end;
end;
constructor TFontEnumerator.Create(ANodeEnumerator: TAvgLvlTreeNodeEnumerator);
constructor TFontEnumerator.Create(ANodeEnumerator: TAvlTreeNodeEnumerator);
begin
FNodeEnumerator := ANodeEnumerator;
end;
@ -418,7 +420,7 @@ begin
result := TCustomFamilyCollectionItem(FNodeEnumerator.Current.Data);
end;
constructor TFamilyEnumerator.Create(ANodeEnumerator: TAvgLvlTreeNodeEnumerator );
constructor TFamilyEnumerator.Create(ANodeEnumerator: TAvlTreeNodeEnumerator);
begin
FNodeEnumerator := ANodeEnumerator;
end;
@ -756,8 +758,9 @@ begin
end;
function TFreeTypeFontCollection.FindFont(AFileName: string): TFontCollectionItem;
var Comp: integer;
node : TAvgLvlTreeNode;
var
Comp: integer;
node: TAvlTreeNode;
begin
node:= FFontList.Root;
while (node<>nil) do begin
@ -775,8 +778,7 @@ begin
result := TFontCollectionItem(node.Data);
end;
function TFreeTypeFontCollection.GetFamily(AName: string
): TCustomFamilyCollectionItem;
function TFreeTypeFontCollection.GetFamily(AName: string): TCustomFamilyCollectionItem;
var
i,j: Integer;
begin
@ -845,8 +847,9 @@ begin
end;
function TFreeTypeFontCollection.FindFamily(AName: string): TFamilyCollectionItem;
var Comp: integer;
node : TAvgLvlTreeNode;
var
Comp: integer;
node: TAvlTreeNode;
begin
node:= FFamilyList.Root;
while (node<>nil) do begin
@ -864,20 +867,19 @@ begin
result := TFamilyCollectionItem(node.Data);
end;
function TFreeTypeFontCollection.CompareFontFileName(Tree: TAvgLvlTree; Data1,
function TFreeTypeFontCollection.CompareFontFileName(Tree: TAvlTree; Data1,
Data2: Pointer): integer;
begin
result := CompareStr(TFontCollectionItem(Data1).Filename,TFontCollectionItem(Data2).Filename);
end;
function TFreeTypeFontCollection.CompareFamilyName(Tree: TAvgLvlTree; Data1,
function TFreeTypeFontCollection.CompareFamilyName(Tree: TAvlTree; Data1,
Data2: Pointer): integer;
begin
result := CompareText(TFamilyCollectionItem(Data1).FamilyName,TFamilyCollectionItem(Data2).FamilyName);
end;
function TFreeTypeFontCollection.GetFont(AFileName: string
): TCustomFontCollectionItem;
function TFreeTypeFontCollection.GetFont(AFileName: string): TCustomFontCollectionItem;
begin
AFilename:= ExpandFileName(AFilename);
result := FindFont(AFilename);
@ -887,8 +889,8 @@ constructor TFreeTypeFontCollection.Create;
begin
FUpdateCount := 0;
FTempFont := nil;
FFontList := TAvgLvlTree.CreateObjectCompare(@CompareFontFileName);
FFamilyList := TAvgLvlTree.CreateObjectCompare(@CompareFamilyName);
FFontList := TAvlTree.CreateObjectCompare(@CompareFontFileName);
FFamilyList := TAvlTree.CreateObjectCompare(@CompareFamilyName);
end;
procedure TFreeTypeFontCollection.Clear;
@ -929,7 +931,7 @@ end;
procedure TFreeTypeFontCollection.RemoveFolder(AFolder: string);
var toBeDeleted: TStringList;
enumerator: TAvgLvlTreeNodeEnumerator;
enumerator: TAvlTreeNodeEnumerator;
i: Integer;
begin
AFolder := ExpandFileName(AFolder);

28
components/lazutils/maps.pp
View File

@ -24,9 +24,9 @@ unit Maps;
interface
uses
Classes, SysUtils, Math, typinfo,
Classes, SysUtils, Math, typinfo, Laz_AVL_Tree,
// LazUtils
FPCAdds, AvgLvlTree;
FPCAdds;
type
TMapIdType = (itu1, its1, itu2, its2, itu4, its4, itu8, its8, itu16, its16,
@ -86,16 +86,16 @@ type
TBaseMap = class(TPersistent)
private
FTree: TAvgLvlTree;
FTree: TAvlTree;
FIdType: TMapIdType;
FDataSize: Cardinal;
FFirst: PMapItem; // First element of our linkedlist
FLast: PMapItem; // Last element of our linkedlist
FIterators: TList; // A List of iterators iterating us
function FindNode(const AId): TAvgLvlTreeNode;
function FindNode(const AId): TAvlTreeNode;
function FindItem(const AId): PMapItem;
procedure FreeData(ANode: TAvgLvlTreeNode);
function TreeCompareID(Sender: TAvgLvlTree; AItem1, AItem2: Pointer): Integer;
procedure FreeData(ANode: TAvlTreeNode);
function TreeCompareID(Sender: TAvlTree; AItem1, AItem2: Pointer): Integer;
//--
procedure IteratorAdd(AIterator: TBaseMapIterator);
procedure IteratorRemove(AIterator: TBaseMapIterator);
@ -252,12 +252,12 @@ begin
inherited Create;
FIdType := AIdType;
FDataSize := ADataSize;
FTree := TAvgLvlTree.CreateObjectCompare(@TreeCompareID);
FTree := TAvlTree.CreateObjectCompare(@TreeCompareID);
end;
function TBaseMap.Delete(const AId): Boolean;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
n: integer;
begin
Node := FindNode(AId);
@ -303,7 +303,7 @@ end;
function TBaseMap.FindItem(const AId): PMapItem;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
begin
Node := FindNode(AId);
if Node = nil
@ -311,7 +311,7 @@ begin
else Result := Node.Data;
end;
function TBaseMap.FindNode(const AId): TAvgLvlTreeNode;
function TBaseMap.FindNode(const AId): TAvlTreeNode;
var
Item: TMapItem;
begin
@ -319,7 +319,7 @@ begin
Result := FTree.Find(@Item);
end;
procedure TBaseMap.FreeData(ANode: TAvgLvlTreeNode);
procedure TBaseMap.FreeData(ANode: TAvlTreeNode);
begin
if ANode = nil then Exit;
FreeData(ANode.Left);
@ -359,7 +359,7 @@ procedure TBaseMap.InternalAdd(const AId, AData);
var
item: PMapItem;
p: Pointer;
Node, NewNode: TAvgLvlTreeNode;
Node, NewNode: TAvlTreeNode;
begin
if FindNode(AId) <> nil
then begin
@ -465,7 +465,7 @@ procedure TBaseMap.ReleaseData(ADataPtr: Pointer);
begin
end;
function TBaseMap.TreeCompareID(Sender: TAvgLvlTree; AItem1, AItem2: Pointer): Integer;
function TBaseMap.TreeCompareID(Sender: TAvlTree; AItem1, AItem2: Pointer): Integer;
var
Item1: PMapItem absolute AItem1;
Item2: PMapItem absolute AItem2;
@ -541,7 +541,7 @@ end;
function TBaseMapIterator.InternalLocate(const AId): Boolean;
var
C: Integer;
Node, LastNext: TAvgLvlTreeNode;
Node, LastNext: TAvlTreeNode;
Item: TMapItem;
begin
ValidateMap;

15
components/synedit/synedithighlighterfoldbase.pas
View File

@ -57,8 +57,13 @@ unit SynEditHighlighterFoldBase;
interface
uses
SysUtils, Classes, math, LCLProc, SynEditHighlighter, SynEditTypes,
LazSynEditText, AvgLvlTree, LazClasses;
SysUtils, Classes, math, Laz_AVL_Tree,
// LCL
LCLProc,
// LazUtils
LazClasses,
// SynEdit
SynEditHighlighter, SynEditTypes, LazSynEditText;
const
NullRange = TSynEditRange(nil);
@ -532,7 +537,7 @@ type
private
FAllocatedCount: integer;
FHighlighterClass: TSynCustomHighlighterClass;
FItems: TAvgLvlTree;
FItems: TAvlTree;
public
constructor Create(TheHighlighterClass: TSynCustomHighlighterClass);
destructor Destroy; override;
@ -2484,7 +2489,7 @@ constructor TSynCustomHighlighterRanges.Create(
TheHighlighterClass: TSynCustomHighlighterClass);
begin
Allocate;
FItems:=TAvgLvlTree.Create(@CompareSynHighlighterRanges);
FItems:=TAvlTree.Create(@CompareSynHighlighterRanges);
end;
destructor TSynCustomHighlighterRanges.Destroy;
@ -2502,7 +2507,7 @@ end;
function TSynCustomHighlighterRanges.GetEqual(Range: TSynCustomHighlighterRange
): TSynCustomHighlighterRange;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
begin
if Range=nil then exit(nil);
Node:=FItems.Find(Range);

24
components/todolist/todolist.pas
View File

@ -59,14 +59,18 @@ unit TodoList;
interface
uses
// FCL, RTL, LCL
Classes, SysUtils, Math, LCLProc, Forms, Controls, Dialogs, StrUtils,
ComCtrls, ActnList, AvgLvlTree, LazUTF8Classes, LCLType, ButtonPanel,
CodeCache, CodeToolManager, BasicCodeTools, FileProcs, LazFileUtils,
LazFileCache, LclIntf, StdCtrls, XMLPropStorage,
// FCL, RTL
Classes, SysUtils, Math, StrUtils, Laz_AVL_Tree,
// LCL
LCLProc, LCLType, LclIntf, Forms, Controls, StdCtrls, Dialogs, ComCtrls,
ActnList, ButtonPanel, XMLPropStorage,
// LazUtils
AvgLvlTree, LazUTF8Classes, LazFileUtils, LazFileCache,
// Codetools
CodeCache, CodeToolManager, BasicCodeTools, FileProcs,
// IDEIntf
LazIDEIntf, IDEImagesIntf, PackageIntf, ProjectIntf, IDEUtils,
// IDE
// ToDoList
ToDoListStrConsts;
@ -178,7 +182,7 @@ type
FLoadingOptions: boolean;
fStartFilename: String;
FOnOpenFile : TOnOpenFile;
fScannedFiles: TAvgLvlTree;// tree of TTLScannedFile
fScannedFiles: TAvlTree;// tree of TTLScannedFile
procedure SetIDEItem(AValue: string);
procedure SetIdleConnected(const AValue: boolean);
@ -255,7 +259,7 @@ var
i: integer;
St : String;
CurOwner: TObject;
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
CurFile: TTLScannedFile;
Units: TStrings;
CurProject: TLazProject;
@ -633,7 +637,7 @@ end;
procedure TIDETodoWindow.FormCreate(Sender: TObject);
begin
fUpdating := False;
fScannedFiles := TAvgLvlTree.Create(@CompareTLScannedFiles);
fScannedFiles := TAvlTree.Create(@CompareTLScannedFiles);
Caption := lisToDoList;
@ -787,7 +791,7 @@ end;
procedure TIDETodoWindow.ScanFile(aFileName: string);
var
ExpandedFilename: String;
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
Tool: TCodeTool;
Code: TCodeBuffer;
CurFile: TTLScannedFile;

7
components/wiki/lazwiki/wiki2chmconvert.pas
View File

@ -33,13 +33,16 @@ unit Wiki2CHMConvert;
interface
uses
Classes, SysUtils, Wiki2HTMLConvert, Wiki2XHTMLConvert, LazLogger, laz2_DOM,
Classes, SysUtils,
{$IFDEF EnableWikiCHMWriter}
wikichmwriter, wikichmfilewriter, wikichmsitemap,
{$ELSE}
chmwriter, chmfilewriter, chmsitemap,
{$ENDIF}
LazUTF8, LazFileUtils, CodeToolsStructs;
// LazUtils
LazLogger, LazUTF8, LazFileUtils, AvgLvlTree,
// LazWiki
Wiki2HTMLConvert, Wiki2XHTMLConvert;
const
CHMImagesDir = '/images/';

9
components/wiki/lazwiki/wiki2xhtmlconvert.pas
View File

@ -25,8 +25,13 @@ unit Wiki2XHTMLConvert;
interface
uses
Classes, SysUtils, WikiFormat, WikiParser, laz2_DOM, LazLogger, LazFileUtils,
laz2_XMLWrite, LazUTF8, BasicCodeTools, KeywordFuncLists, CodeToolsStructs;
Classes, SysUtils,
// LazUtils
laz2_XMLWrite, LazUTF8, laz2_DOM, LazLogger, LazFileUtils, AvgLvlTree,
// CodeTools
BasicCodeTools, KeywordFuncLists,
// LazWiki
WikiFormat, WikiParser;
type
TW2XHTMLStackItem = record

27
components/wiki/lazwiki/wikiformat.pas
View File

@ -27,9 +27,13 @@ unit WikiFormat;
interface
uses
Classes, SysUtils, WikiParser, WikiStrConsts, laz2_XMLRead, LazFileUtils,
laz2_DOM, LazLogger, LazUTF8, AvgLvlTree, KeywordFuncLists, CodeToolsStructs,
BasicCodeTools;
Classes, SysUtils, Laz_AVL_Tree,
// LazUtils
LazFileUtils, laz2_XMLRead, laz2_DOM, LazLogger, LazUTF8, AvgLvlTree,
// Codetools
BasicCodeTools, KeywordFuncLists,
// LazWiki
WikiParser, WikiStrConsts;
type
TWiki2FormatConverter = class;
@ -70,8 +74,8 @@ type
FImagesDir: string;
FOutputDir: string;
fPages: TFPList; // list of TW2FormatPage
fPagesSortFilename: TAvgLvlTree; // TW2FormatPage sorted for WikiFilename
fPagesSortDocumentName: TAvgLvlTree; // TW2FormatPage sorted for WikiDocumentName
fPagesSortFilename: TAvlTree; // TW2FormatPage sorted for WikiFilename
fPagesSortDocumentName: TAvlTree; // TW2FormatPage sorted for WikiDocumentName
FPageClass: TW2FormatPageClass;
function GetPages(Index: integer): TW2FormatPage;
procedure SetOutputDir(AValue: string);
@ -164,8 +168,8 @@ constructor TWiki2FormatConverter.Create;
begin
FPageClass:=TW2FormatPage;
fPages:=TFPList.Create;
fPagesSortFilename:=TAvgLvlTree.Create(@ComparePagesWithFilenames);
fPagesSortDocumentName:=TAvgLvlTree.Create(@ComparePagesWithDocumentNames);
fPagesSortFilename:=TAvlTree.Create(@ComparePagesWithFilenames);
fPagesSortDocumentName:=TAvlTree.Create(@ComparePagesWithDocumentNames);
FTitle:='FPC/Lazarus Wiki (offline, generated '+DatetoStr(Now)+')';
FImagesDir:='images';
FNoWarnBaseURLs:=TStringToStringTree.Create(true);
@ -193,10 +197,9 @@ begin
FNoWarnBaseURLs.Clear;
end;
function TWiki2FormatConverter.GetPageWithFilename(Filename: string
): TW2FormatPage;
function TWiki2FormatConverter.GetPageWithFilename(Filename: string): TW2FormatPage;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
begin
if Filename='' then exit(nil);
Node:=fPagesSortFilename.FindKey(Pointer(Filename),@CompareFilenameWithPage);
@ -209,7 +212,7 @@ end;
function TWiki2FormatConverter.GetPageWithDocumentName(DocumentName: string
): TW2FormatPage;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
begin
if DocumentName='' then exit(nil);
Node:=fPagesSortDocumentName.FindKey(Pointer(DocumentName),@CompareDocumentNameWithPage);
@ -291,7 +294,7 @@ end;
procedure TWiki2FormatConverter.GetPageTranslations(DocumentName: string; out
LangToPage: TStringToPointerTree);
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
Page: TW2FormatPage;
begin
LangToPage:=TStringToPointerTree.Create(false);

4
components/wiki/test/wikisearchoptions.pas
View File

@ -25,7 +25,7 @@ unit WikiSearchOptions;
interface
uses
Classes, SysUtils, FileUtil, LazLogger, BasicCodeTools,
Classes, SysUtils, FileUtil, LazLogger, AvgLvlTree, BasicCodeTools,
CodeToolsStructs, WikiHelpManager, WikiStrConsts, WikiFormat, Forms, Controls,
Graphics, Dialogs, ExtCtrls, StdCtrls, ComCtrls, Grids;
@ -325,7 +325,7 @@ end;
function TWikiSearchOptsWnd.GetLanguages: string;
var
S2SItem: PStringToStringTreeItem;
S2SItem: PStringToStringItem;
begin
Result:='';
if not FLanguages.Contains('') then

14
converter/chgencodingdlg.pas
View File

@ -31,13 +31,13 @@ interface
uses
// RTL + FCL
Classes, SysUtils, AVL_Tree, RegExpr,
Classes, SysUtils, RegExpr, Laz_AVL_Tree,
// LCL
LCLProc, Forms, Controls, ExtCtrls, StdCtrls, ComCtrls, Buttons,
// CodeTools
CodeCache, CodeToolsStructs, CodeToolManager, FileProcs,
CodeCache, CodeToolManager, FileProcs,
// LazUtils
LConvEncoding, LazFileUtils, LazFileCache,
LConvEncoding, LazFileUtils, LazFileCache, AvgLvlTree,
// IDEIntf
IDEWindowIntf, SrcEditorIntf, IDEHelpIntf,
// IDE
@ -179,7 +179,7 @@ var
SrcEdit: TSourceEditorInterface;
Encoding, OldEncoding, NewEncoding: String;
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
Filename: String;
HasChanged: boolean;
li, Cur: TListItem;
@ -191,7 +191,7 @@ begin
OldCount := PreviewListView.Items.Count;
Node:=FFiles.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
Filename:=Item^.Name;
Encoding:=Item^.Value;
@ -356,7 +356,7 @@ end;
procedure TChgEncodingDialog.UpdatePreview;
var
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
Filename: String;
Encoding: String;
li: TListItem;
@ -378,7 +378,7 @@ begin
PreviewListView.BeginUpdate;
Node:=FFiles.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
Filename:=Item^.Name;
Encoding:=Item^.Value;
DebugLn(['TChgEncodingDialog.UpdatePreview Filename=',Filename,' Encoding=',Encoding]);

18
converter/convcodetool.pas
View File

@ -31,19 +31,19 @@ unit ConvCodeTool;
interface
uses
// RTL + FCL + LCL
Classes, SysUtils, contnrs, strutils, Forms, Controls, Dialogs,
// RTL + FCL
Classes, SysUtils, contnrs, strutils,
// LCL
Forms, Controls,
// CodeTools
CodeToolManager, StdCodeTools, CodeTree, CodeAtom, FileProcs,
FindDeclarationTool, LFMTrees,
ExprEval, KeywordFuncLists, BasicCodeTools, LinkScanner,
CodeCache, SourceChanger, CustomCodeTool, CodeToolsStructs,
CodeToolManager, CodeTree, CodeAtom, FileProcs, KeywordFuncLists, BasicCodeTools,
LinkScanner, CodeCache, SourceChanger, CodeToolsStructs,
// LazUtils
LazFileUtils,
LazFileUtils, AvgLvlTree,
// IdeIntf
LazIDEIntf, IDEExternToolIntf,
IDEExternToolIntf,
// IDE
FormEditor, LazarusIDEStrConsts,
LazarusIDEStrConsts,
// Converter
ConverterTypes, ConvertSettings, ReplaceNamesUnit, ReplaceFuncsUnit;

10
converter/convertdelphi.pas
View File

@ -32,12 +32,14 @@ unit ConvertDelphi;
interface
uses
// RTL + FCL + LCL
Classes, SysUtils, contnrs, IniFiles, LCLProc, Forms, Controls, Dialogs,
// RTL + FCL
Classes, SysUtils, contnrs, IniFiles,
// LCL
LCLProc, Forms, Controls, Dialogs,
// CodeTools
CodeToolManager, DefineTemplates, CodeCache, LinkScanner, FileProcs, CodeToolsStructs,
CodeToolManager, DefineTemplates, CodeCache, LinkScanner, FileProcs,
// LazUtils
LConvEncoding, FileUtil, LazFileUtils, LazUTF8, LazUTF8Classes,
LConvEncoding, FileUtil, LazFileUtils, LazUTF8, LazUTF8Classes, AvgLvlTree,
// IDEIntf
ComponentReg, IDEDialogs,
LazIDEIntf, PackageIntf, ProjectIntf, IDEExternToolIntf, IDEOptionsIntf,

12
converter/convertsettings.pas
View File

@ -30,13 +30,13 @@ unit ConvertSettings;
interface
uses
Classes, SysUtils, AVL_Tree,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
Forms, Controls, Dialogs, StdCtrls, Buttons, ButtonPanel, ComCtrls, LCLProc,
Forms, Controls, Dialogs, StdCtrls, Buttons, ButtonPanel, ComCtrls,
// LazUtils
FileUtil, LazFileUtils, DividerBevel, LazConfigStorage,
FileUtil, LazFileUtils, DividerBevel, LazConfigStorage, AvgLvlTree,
// CodeTools
CodeToolsStructs, CodeToolManager, CodeCache,
CodeToolManager, CodeCache,
// IdeIntf
BaseIDEIntf, IDEMsgIntf, IDEExternToolIntf,
// IDE
@ -335,7 +335,7 @@ end;
procedure TConvertSettings.SaveStringToStringTree(Path: string; Tree: TStringToStringTree);
var
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
SubPath: String;
i: Integer;
begin
@ -344,7 +344,7 @@ begin
Node:=Tree.Tree.FindLowest;
i:=0;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
SubPath:=Path+'Item'+IntToStr(i)+'/';
fConfigStorage.SetDeleteValue(SubPath+'Name',Item^.Name,'');
fConfigStorage.SetDeleteValue(SubPath+'Value',Item^.Value,'');

2
converter/missingpropertiesdlg.pas
View File

@ -36,7 +36,7 @@ uses
Classes, SysUtils, contnrs,
LCLProc, Forms, Controls, Grids, LResources, Dialogs, Buttons, StdCtrls, ExtCtrls,
// LazUtils
LazFileUtils, LazUTF8Classes, LazUTF8,
LazFileUtils, LazUTF8Classes, LazUTF8, AvgLvlTree,
// components
SynHighlighterLFM, SynEdit, SynEditMiscClasses,
// codetools

2
converter/replacenamesunit.pas
View File

@ -12,7 +12,7 @@ uses
// Codetools
CodeToolsStructs,
// LazUtils
FileUtil,
FileUtil, AvgLvlTree,
// IDE, converter
LazarusIDEStrConsts, ConverterTypes;

19
converter/usedunits.pas
View File

@ -31,13 +31,16 @@ unit UsedUnits;
interface
uses
Classes, SysUtils, AVL_Tree, Forms, Controls, Dialogs,
// IDE
LazarusIDEStrConsts, IDEExternToolIntf,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
Forms, Controls,
// LazUtils
AvgLvlTree,
// codetools
CodeToolManager, StdCodeTools, CustomCodeTool, CodeTree, CodeAtom, CodeCache,
LinkScanner, KeywordFuncLists, SourceChanger, CodeToolsStrConsts, CodeToolsStructs,
FileProcs,
StdCodeTools, CodeTree, CodeAtom, CodeCache,
LinkScanner, KeywordFuncLists, SourceChanger, CodeToolsStrConsts,
// IDE + IdeIntf
LazarusIDEStrConsts, IDEExternToolIntf,
// Converter
ConverterTypes, ConvCodeTool, ConvertSettings, ReplaceNamesUnit;
@ -586,7 +589,7 @@ var
UnitUpdater: TStringMapUpdater;
MapToEdit: TStringToStringTree;
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
UnitN, s: string;
i: Integer;
begin
@ -620,7 +623,7 @@ begin
// Iterate the map and rename / remove.
Node:=MapToEdit.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
UnitN:=Item^.Name;
s:=Item^.Value;
if fMainUsedUnits.fExistingUnits.IndexOf(UnitN)<>-1 then

25
designer/changeclassdialog.pas
View File

@ -35,12 +35,15 @@ unit ChangeClassDialog;
interface
uses
Classes, SysUtils, LCLProc, LResources, Forms, Controls, Graphics, Dialogs,
StdCtrls, Buttons, AVGLvlTree, LFMTrees, CodeCache, CodeToolManager, LCLType,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
LCLProc, LCLType, LResources, Forms, Controls, Dialogs, StdCtrls, ButtonPanel,
// Codetools
LFMTrees, CodeCache, CodeToolManager,
// IdeIntf
ComponentReg, PropEdits, ComponentEditors, FormEditingIntf, SrcEditorIntf,
// IDE
SrcEditorIntf, PropEdits, LazarusIDEStrConsts, ComponentReg, ComponentEditors,
FormEditingIntf, IDEDialogs, CheckLFMDlg, Project, MainIntf, ExtCtrls,
ButtonPanel;
LazarusIDEStrConsts, IDEDialogs, CheckLFMDlg, Project, MainIntf;
type
@ -59,7 +62,7 @@ type
procedure NewClassComboBoxKeyUp(Sender: TObject; var Key: Word;
{%H-}Shift: TShiftState);
private
FClasses: TAvgLvlTree;
FClasses: TAvlTree;
FNewClass: TClass;
FThePersistent: TPersistent;
procedure SetNewClass(const AValue: TClass);
@ -70,7 +73,7 @@ type
procedure FillAncestorListBox(AClass: TClass; AListBox: TListBox);
procedure AddClass(const AClass: TPersistentClass);
procedure AddComponentClass(const AClass: TComponentClass);
function CompareClasses({%H-}Tree: TAvgLvlTree; Class1, Class2: TClass): integer;
function CompareClasses({%H-}Tree: TAvlTree; Class1, Class2: TClass): integer;
public
destructor Destroy; override;
procedure FillNewClassComboBox;
@ -351,7 +354,7 @@ end;
procedure TChangeClassDlg.UpdateNewInfo;
var
ANode: TAvgLvlTreeNode;
ANode: TAvlTreeNode;
begin
FNewClass:=nil;
if FClasses<>nil then begin
@ -405,7 +408,7 @@ begin
AddClass(AClass);
end;
function TChangeClassDlg.CompareClasses(Tree: TAvgLvlTree; Class1,Class2: TClass): integer;
function TChangeClassDlg.CompareClasses(Tree: TAvlTree; Class1,Class2: TClass): integer;
// sort:
// transforming ThePersistent to descending classes is easy
// transforming ThePersistent to ascending classes is medium
@ -461,12 +464,12 @@ end;
procedure TChangeClassDlg.FillNewClassComboBox;
var
ANode: TAvgLvlTreeNode;
ANode: TAvlTreeNode;
List: TStringList;
begin
// create/clear tree
if FClasses=nil then
FClasses:=TAvgLvlTree.CreateObjectCompare(TObjectSortCompare(@CompareClasses))
FClasses:=TAvlTree.CreateObjectCompare(TObjectSortCompare(@CompareClasses))
else
FClasses.Clear;
// add class of ThePersistent

4
designer/customnonformdesigner.pas
View File

@ -30,8 +30,8 @@ unit CustomNonFormDesigner;
interface
uses
Classes, SysUtils, LCLProc, Graphics, GraphType, Forms, Controls,
IDEProcs, FormEditingIntf;
Classes, SysUtils,
FormEditingIntf;
type

16
designer/jitforms.pp
View File

@ -46,9 +46,9 @@ uses
{$IFDEF IDE_MEM_CHECK}
MemCheck,
{$ENDIF}
Classes, SysUtils, TypInfo,
Classes, SysUtils, TypInfo, Laz_AVL_Tree,
// LCL
Forms, Controls, Dialogs, LResources, LCLMemManager, LCLIntf, LCLProc,
Forms, Controls, Dialogs, LResources, LCLMemManager, LCLProc,
//LazUtils
AvgLvlTree,
// CodeTools
@ -56,7 +56,7 @@ uses
// IdeIntf
PackageDependencyIntf, PropEditUtils, PropEdits, UnitResources, IDEDialogs,
// IDE
IDEProcs, PackageDefs, BasePkgManager, DesignerProcs;
IDEProcs, PackageDefs;
type
//----------------------------------------------------------------------------
@ -274,7 +274,7 @@ type
TJITMethods = class
private
fClearing: boolean;
fMethods: TAvgLvlTree;// sorted with CompareJITMethod
fMethods: TAvlTree; // sorted with CompareJITMethod
procedure InternalAdd(const AMethod: TJITMethod);
procedure InternalRemove(const AMethod: TJITMethod);
public
@ -2014,7 +2014,7 @@ end;
constructor TJITMethods.Create;
begin
fMethods:=TAvgLvlTree.Create(@CompareJITMethod);
fMethods:=TAvlTree.Create(@CompareJITMethod);
end;
destructor TJITMethods.Destroy;
@ -2045,7 +2045,7 @@ function TJITMethods.Find(aClass: TClass;
const aMethodName: shortstring): TJITMethod;
var
CurMethod: TJITMethod;
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Comp: LongInt;
begin
//DebugLn(['TJITMethods.Find Class=',dbgsname(aClass),' aMethodName=',aMethodName]);
@ -2098,9 +2098,9 @@ end;
procedure TJITMethods.DeleteAllOfClass(aClass: TClass);
var
CurMethod: TJITMethod;
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Comp: LongInt;
NextNode: TAvgLvlTreeNode;
NextNode: TAvlTreeNode;
begin
Node:=fMethods.Root;
while (Node<>nil) do begin

2
designer/menutemplates.pas
View File

@ -9,7 +9,7 @@ uses
Buttons, Controls, Dialogs, StdCtrls, ExtCtrls, Menus,
ComCtrls, Forms, Graphics, Themes, LCLType, LCLIntf, LCLProc,
// LazUtils
LazUTF8, LazFileUtils, Laz2_XMLCfg,
LazFileUtils, Laz2_XMLCfg,
// IdeIntf
IDEDialogs,
// IDE

7
designer/noncontroldesigner.pas
View File

@ -31,8 +31,11 @@ unit NonControlDesigner;
interface
uses
Classes, SysUtils, Math, LCLProc, Graphics, GraphType, Forms, Controls,
IDEProcs, DesignerProcs, FormEditingIntf, CustomNonFormDesigner;
Classes, SysUtils, Math,
// LCL
LCLProc, Graphics, GraphType, Forms, Controls,
// IdeIntf
FormEditingIntf, CustomNonFormDesigner;
type

16
designer/taborderdlg.pas
View File

@ -32,11 +32,9 @@ unit TabOrderDlg;
interface
uses
Classes, SysUtils,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
Forms, Controls, Dialogs, Buttons, ExtCtrls, StdCtrls, ComCtrls, LCLType, LCLProc,
// LazUtils
AvgLvlTree,
// IdeIntf
PropEdits, IDEDialogs,
//IDE
@ -64,9 +62,9 @@ type
FUpdating: Boolean;
procedure SwapNodes(ANode1, ANode2, NewSelected: TTreeNode);
procedure CheckButtonsEnabled;
procedure CreateCandidates(OwnerComponent: TComponent; Candidates: TAvgLvlTree);
procedure CreateCandidates(OwnerComponent: TComponent; Candidates: TAvlTree);
procedure CreateNodes(ParentControl: TWinControl; ParentNode: TTreeNode;
Candidates: TAvgLvlTree);
Candidates: TAvlTree);
procedure RefreshTree;
procedure OnSomethingChanged;
procedure OnPersistentAdded({%H-}APersistent: TPersistent; {%H-}Select: boolean);
@ -321,7 +319,7 @@ begin
end;
procedure TTabOrderDialog.CreateCandidates(OwnerComponent: TComponent;
Candidates: TAvgLvlTree);
Candidates: TAvlTree);
var
i: Integer;
AComponent: TComponent;
@ -345,7 +343,7 @@ begin
end;
end;
procedure TTabOrderDialog.CreateNodes(ParentControl: TWinControl; ParentNode: TTreeNode; Candidates: TAvgLvlTree);
procedure TTabOrderDialog.CreateNodes(ParentControl: TWinControl; ParentNode: TTreeNode; Candidates: TAvlTree);
// Add all controls in Designer to ItemTreeview.
var
AControl: TControl;
@ -390,7 +388,7 @@ end;
procedure TTabOrderDialog.RefreshTree;
var
LookupRoot: TPersistent;
Candidates: TAvgLvlTree;
Candidates: TAvlTree;
begin
if not IsVisible then Exit;
ItemTreeview.BeginUpdate;
@ -398,7 +396,7 @@ begin
ItemTreeview.Items.Clear;
LookupRoot := GlobalDesignHook.LookupRoot;
if Assigned(LookupRoot) and (LookupRoot is TWinControl) then begin
Candidates := TAvgLvlTree.Create;
Candidates := TAvlTree.Create;
try
CreateCandidates(TComponent(LookupRoot), Candidates);
CreateNodes(TWinControl(LookupRoot), nil, Candidates);

2
ide/addtoprojectdlg.pas
View File

@ -34,7 +34,7 @@ unit AddToProjectDlg;
interface
uses
Classes, SysUtils, AVL_Tree,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
Forms, Controls, Buttons, ComCtrls, StdCtrls, Dialogs, ButtonPanel,
// LazUtils

2
ide/buildmanager.pas
View File

@ -35,7 +35,7 @@ interface
uses
// RTL + FCL
Classes, SysUtils, AVL_Tree,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
InterfaceBase, LCLPlatformDef, LCLProc, Dialogs, Forms, Controls,
// CodeTools

16
ide/buildprojectdlg.pas
View File

@ -28,11 +28,13 @@ unit BuildProjectDlg;
interface
uses
Classes, SysUtils, Math, AVL_Tree, Forms, Controls,
Dialogs, ButtonPanel, StdCtrls, ComCtrls, Masks, LCLIntf,
FileProcs, LazFileUtils, LazFileCache, LazUtilities,
Classes, SysUtils, Math, Laz_AVL_Tree,
// LCL
Forms, Controls, Dialogs, ButtonPanel, StdCtrls, ComCtrls, Masks, LCLIntf,
// LazUtils
LazFileUtils, LazFileCache, LazUtilities, AvgLvlTree,
// codetools
CodeToolManager, DirectoryCacher, CodeToolsStructs,
FileProcs, CodeToolManager, DirectoryCacher,
// IDEIntf
IDEDialogs, IDEImagesIntf, PackageIntf,
// IDE
@ -518,7 +520,7 @@ function TCleanBuildProjectDialog.DeleteFiles: TModalResult;
var
Files: TFilenameToStringTree;
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
MaskList: TMaskList;
Filename: String;
SourceFiles: TStringList;
@ -531,7 +533,7 @@ begin
// warn before deleting sources
Node:=Files.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
Filename:=Item^.Name;
if MaskList.Matches(ExtractFilename(Filename)) then
SourceFiles.Add(Filename);
@ -549,7 +551,7 @@ begin
Node:=Files.Tree.FindLowest;
Quiet:=false;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
Node:=Files.Tree.FindSuccessor(Node);
Filename:=Item^.Name;
//debugln(['TBuildProjectDialog.DeleteFiles ',Filename,' ',FileExistsUTF8(Filename)]);

18
ide/checkcompileropts.pas
View File

@ -32,17 +32,19 @@ unit CheckCompilerOpts;
interface
uses
Classes, SysUtils, Forms, Controls, Dialogs, FileUtil,
Clipbrd, StdCtrls, AVL_Tree, Menus, ExtCtrls, ButtonPanel, ComCtrls,
// codetools
CodeToolManager, FileProcs, LazFileCache, LazFileUtils, LazUTF8,
DefineTemplates, CodeToolsStructs,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
Forms, Controls, Dialogs, Clipbrd, StdCtrls, Menus, ExtCtrls, ButtonPanel, ComCtrls,
// LazUtils
LazFileCache, FileUtil, LazFileUtils, LazUTF8, AvgLvlTree,
// Codetools
CodeToolManager, FileProcs, DefineTemplates,
// IDEIntf
ProjectIntf, MacroIntf, IDEExternToolIntf, LazIDEIntf, IDEDialogs,
PackageIntf, IDEMsgIntf,
// IDE
Project, PackageSystem, IDEProcs,
LazarusIDEStrConsts, PackageDefs, CompilerOptions, TransferMacros, LazConf;
LazarusIDEStrConsts, PackageDefs, CompilerOptions, TransferMacros;
type
TCompilerOptionsTest = (
@ -528,7 +530,7 @@ var
MinPPU: String;
MaxPPU: String;
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
procedure CheckFileAge(const aFilename: string);
var
@ -599,7 +601,7 @@ begin
// b) not updated
Node:=CfgCache.Units.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
if (Item^.Value<>'') and (CompareFileExt(Item^.Value,'.ppu',false)=0) then
CheckFileAge(Item^.Value);
Node:=CfgCache.Units.Tree.FindSuccessor(Node);

23
ide/codebrowser.pas
View File

@ -45,20 +45,19 @@ unit CodeBrowser;
interface
uses
// RTL + FCL + LCL
Classes, SysUtils, types, AVL_Tree,
LCLProc, LResources, Forms, Controls, Graphics, Dialogs, Clipbrd, StdCtrls,
ExtCtrls, ComCtrls, Buttons, Menus, HelpIntfs, LCLIntf,
// RTL + FCL
Classes, SysUtils, types, Laz_AVL_Tree,
// LCL
LCLProc, Forms, Controls, Graphics, Dialogs, Clipbrd, StdCtrls,
ExtCtrls, ComCtrls, Buttons, Menus, HelpIntfs,
// CodeTools
BasicCodeTools, DefineTemplates, CodeTree, CodeCache,
CodeToolsStructs, CodeToolManager, PascalParserTool, LinkScanner, FileProcs,
CodeIndex, StdCodeTools, SourceLog, CustomCodeTool,
BasicCodeTools, DefineTemplates, CodeTree, CodeCache, CodeToolManager,
PascalParserTool, LinkScanner, FileProcs, CodeIndex, StdCodeTools, SourceLog,
// LazUtils
LazFileUtils, LazUtilities,
LazFileUtils, LazUtilities, AvgLvlTree,
// IDEIntf
IDEWindowIntf, SrcEditorIntf, IDEMsgIntf, IDEDialogs, LazConfigStorage,
IDEHelpIntf, PackageIntf, IDECommands, LazIDEIntf,
IDEExternToolIntf,
IDEHelpIntf, PackageIntf, IDECommands, LazIDEIntf, IDEExternToolIntf,
// IDE
Project, DialogProcs, PackageSystem, PackageDefs, LazarusIDEStrConsts,
IDEOptionDefs, etFPCMsgParser, BasePkgManager, EnvironmentOpts;
@ -1364,7 +1363,7 @@ var
Filename: String;
ConfigCache: TFPCTargetConfigCache;
Node: TAVLTreeNode;
Item: PStringToStringTreeItem;
Item: PStringToStringItem;
begin
// use unitset of the lazarus source directory
LazDir:=AppendPathDelim(EnvironmentOptions.GetParsedLazarusDirectory);
@ -1379,7 +1378,7 @@ var
if (ConfigCache=nil) or (ConfigCache.Units=nil) then exit;
Node:=ConfigCache.Units.Tree.FindLowest;
while Node<>nil do begin
Item:=PStringToStringTreeItem(Node.Data);
Item:=PStringToStringItem(Node.Data);
Filename:=Item^.Value;
if (CompareFileExt(Filename,'ppu',false)=0) then begin
// search source in fpc sources

17
ide/codeexplopts.pas
View File

@ -34,8 +34,9 @@ unit CodeExplOpts;
interface
uses
// RTL + FCL + LCL
Classes, SysUtils,
// RTL + FCL
Classes, SysUtils, Laz_AVL_Tree,
// LCL
LCLProc, Forms, Controls, Graphics, Dialogs, Buttons,
// CodeTools
BasicCodeTools, FileProcs,
@ -154,7 +155,7 @@ type
FObserverCategories: TCEObserverCategories;
FFollowCursor: boolean;
FMode : TCodeExplorerMode;
FObserverIgnoreConstants: TAvgLvlTree;// tree of AnsiString
FObserverIgnoreConstants: TAvlTree;// tree of AnsiString
FOptionsFilename: string;
FPage: TCodeExplorerPage;
FRefresh: TCodeExplorerRefresh;
@ -218,7 +219,7 @@ type
// Observer
property ObserveCharConst: boolean read FObserveCharConst write SetObserveCharConst default DefaultCOureCharConst;
property ObserverCategories: TCEObserverCategories read FObserverCategories write SetObserverCategories default DefaultCodeObserverCategories;
property ObserverIgnoreConstants: TAvgLvlTree read FObserverIgnoreConstants;
property ObserverIgnoreConstants: TAvlTree read FObserverIgnoreConstants;
property COIgnoreConstInFuncs: TStringToStringTree read FCOIgnoreConstInFuncs;
property LongParamListCount: integer read FLongParamListCount write SetLongParamListCount default DefaultCOLongParamListCount;
property LongProcLineCount: integer read FLongProcLineCount write SetLongProcLineCount default DefaultCOLongProcLineCount;
@ -448,7 +449,7 @@ end;
constructor TCodeExplorerOptions.Create;
begin
FOptionsFilename:=AppendPathDelim(GetPrimaryConfigPath)+'codeexploreroptions.xml';
FObserverIgnoreConstants:=TAvgLvlTree.Create(TListSortCompare(@CompareAtom));
FObserverIgnoreConstants:=TAvlTree.Create(TListSortCompare(@CompareAtom));
FCOIgnoreConstInFuncs:=TStringToStringTree.Create(false);
Clear;
LoadDefaults_COIgnoreConstants;
@ -730,7 +731,7 @@ end;
function TCodeExplorerOptions.CreateListOfCOIgnoreConstants: TStrings;
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
s: String;
begin
Result:=TStringList.Create;
@ -745,7 +746,7 @@ end;
procedure TCodeExplorerOptions.Clear_COIgnoreConstants;
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
s: String;
begin
if FObserverIgnoreConstants.Count=0 then exit;
@ -787,7 +788,7 @@ end;
function TCodeExplorerOptions.CreateListOfCOIgnoreConstInFuncs: TStrings;
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
s: String;
begin
Result:=TStringList.Create;

27
ide/codeexplorer.pas
View File

@ -38,18 +38,18 @@ interface
{$I ide.inc}
uses
// FCL+LCL
Classes, SysUtils, types, LCLProc, LCLType, Forms, Controls, Graphics,
Dialogs, Buttons, ComCtrls, Menus, AvgLvlTree, StdCtrls, ExtCtrls,
// RTL+FCL
Classes, SysUtils, types, Laz_AVL_Tree,
// LCL
LCLProc, LCLType, Forms, Controls, Dialogs, Buttons, ComCtrls, Menus, StdCtrls, ExtCtrls,
// CodeTools
FileProcs, BasicCodeTools, CustomCodeTool, CodeToolManager, CodeAtom,
CodeCache, CodeTree, KeywordFuncLists, FindDeclarationTool, DirectivesTree,
PascalParserTool,
// IDE Intf
// IDEIntf
LazIDEIntf, IDECommands, MenuIntf, SrcEditorIntf, IDEDialogs,
// IDE
KeyMapping, LazarusIDEStrConsts, EnvironmentOpts, IDEOptionDefs, InputHistory,
IDEProcs, CodeExplOpts;
LazarusIDEStrConsts, IDEOptionDefs, IDEProcs, CodeExplOpts;
type
TCodeExplorerView = class;
@ -238,8 +238,8 @@ type
function OnExpandedStateGetNodeText(Node: TTreeNode): string;
protected
fLastCodeTool: TCodeTool;
fCodeSortedForStartPos: TAvgLvlTree;// tree of TTreeNode sorted for TViewNodeData(Node.Data).StartPos, secondary EndPos
fNodesWithPath: TAvgLvlTree; // tree of TViewNodeData sorted for Path and Params
fCodeSortedForStartPos: TAvlTree;// tree of TTreeNode sorted for TViewNodeData(Node.Data).StartPos, secondary EndPos
fNodesWithPath: TAvlTree; // tree of TViewNodeData sorted for Path and Params
procedure ApplyCodeFilter;
procedure ApplyDirectivesFilter;
function CompareCodeNodes(Node1, Node2: TTreeNode): integer;
@ -522,7 +522,7 @@ begin
CERefreshIDEMenuCommand.OnClick:=@RefreshMenuItemClick;
CERenameIDEMenuCommand.OnClick:=@RenameMenuItemClick;
fNodesWithPath:=TAvgLvlTree.Create(@CompareViewNodePathsAndParams);
fNodesWithPath:=TAvlTree.Create(@CompareViewNodePathsAndParams);
Application.AddOnUserInputHandler(@OnUserInput);
LazarusIDE.AddHandlerOnIDEClose(@OnCloseIDE);
@ -2512,7 +2512,7 @@ var
end;
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
Node: TTreeNode;
NodeData: TViewNodeData;
begin
@ -2553,8 +2553,7 @@ begin
if (NodeData<>nil) and (NodeData.StartPos>0)
and (NodeData.EndPos>=NodeData.StartPos) then begin
if fCodeSortedForStartPos=nil then
fCodeSortedForStartPos:=
TAvgLvlTree.Create(TListSortCompare(@CompareViewNodeDataStartPos));
fCodeSortedForStartPos:=TAvlTree.Create(TListSortCompare(@CompareViewNodeDataStartPos));
fCodeSortedForStartPos.Add(TVNode);
end;
TVNode:=TVNode.GetNext;
@ -2705,7 +2704,7 @@ procedure TCodeExplorerView.CreateNodePath(ACodeTool: TCodeTool;
aNodeData: TObject);
var
NodeData: TViewNodeData absolute aNodeData;
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
begin
if NodeData.CTNode.Desc=ctnProcedure then
NodeData.Path:=GetCTNodePath(ACodeTool,NodeData.CTNode);
@ -2727,7 +2726,7 @@ procedure TCodeExplorerView.AddImplementationNode(ACodeTool: TCodeTool;
CodeNode: TCodeTreeNode);
var
NodeData: TViewNodeData;
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
DeclData: TViewNodeData;
begin
if (CodeNode.Desc=ctnProcedure)

29
ide/codehelp.pas
View File

@ -39,21 +39,24 @@ unit CodeHelp;
interface
uses
// RTL + FCL + LCL
Classes, SysUtils, LCLType, LCLProc, Forms, Controls, FileUtil, Dialogs,
// RTL + FCL
Classes, SysUtils, Laz_AVL_Tree,
// LCL
LCLProc, Forms, Controls, Dialogs,
// CodeTools
CodeAtom, CodeTree, CodeToolManager, FindDeclarationTool, BasicCodeTools,
KeywordFuncLists, PascalParserTool, CodeCache, CacheCodeTools, CustomCodeTool,
FileProcs, DefineTemplates, CodeToolsStructs,
// LazUtils
AvgLvlTree, LazFileUtils, LazUTF8, LazFileCache, Laz2_DOM, Laz2_XMLRead, Laz2_XMLWrite,
AvgLvlTree, FileUtil, LazFileUtils, LazUTF8, LazFileCache,
Laz2_DOM, Laz2_XMLRead, Laz2_XMLWrite,
// SynEdit
SynHighlighterPas,
// IDEIntf
IDECommands, IDEMsgIntf, MacroIntf, PackageIntf, LazHelpIntf, ProjectIntf,
IDEDialogs, IDEHelpIntf, LazIDEIntf, IDEExternToolIntf,
// IDE
EditorOptions, LazarusIDEStrConsts, CompilerOptions, IDEProcs, PackageDefs,
EditorOptions, LazarusIDEStrConsts, IDEProcs, PackageDefs,
EnvironmentOpts, TransferMacros, PackageSystem, DialogProcs, KeyMapping;
const
@ -231,10 +234,10 @@ type
TCodeHelpManager = class(TComponent)
private
FDocs: TAvgLvlTree;// tree of loaded TLazFPDocFile
FDocs: TAvlTree;// tree of loaded TLazFPDocFile
FHandlers: array[TCodeHelpManagerHandler] of TMethodList;
FPasHighlighter: TSynPasSyn;
FSrcToDocMap: TAvgLvlTree; // tree of TCHSourceToFPDocFile sorted for SourceFilename
FSrcToDocMap: TAvlTree; // tree of TCHSourceToFPDocFile sorted for SourceFilename
FDeclarationCache: TDeclarationInheritanceCache;
procedure AddHandler(HandlerType: TCodeHelpManagerHandler;
const AMethod: TMethod; {%H-}AsLast: boolean = false);
@ -1182,7 +1185,7 @@ var
CurUnitName: String;
UnitSet: TFPCUnitSetCache;
IsInFPCSrc: Boolean;
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
begin
Result:='';
NewOwner:=nil;
@ -1354,8 +1357,8 @@ end;
constructor TCodeHelpManager.Create(TheOwner: TComponent);
begin
inherited Create(TheOwner);
FDocs:=TAvgLvlTree.Create(@CompareLazFPDocFilenames);
FSrcToDocMap:=TAvgLvlTree.Create(@CompareLDSrc2DocSrcFilenames);
FDocs:=TAvlTree.Create(@CompareLazFPDocFilenames);
FSrcToDocMap:=TAvlTree.Create(@CompareLDSrc2DocSrcFilenames);
FDeclarationCache:=TDeclarationInheritanceCache.Create(
@CodeToolBoss.FindDeclarationAndOverload,
@CodeToolBoss.GetCodeTreeNodesDeletedStep);
@ -1375,7 +1378,7 @@ end;
function TCodeHelpManager.FindFPDocFile(const Filename: string): TLazFPDocFile;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
begin
Node:=FDocs.FindKey(Pointer(Filename),@CompareAnsistringWithLazFPDocFile);
if Node<>nil then
@ -1705,7 +1708,7 @@ var
var
CodeBuf: TCodeBuffer;
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
MapEntry: TCHSourceToFPDocFile;
begin
Result:='';
@ -1802,7 +1805,7 @@ var
CacheWasUsed: boolean;
AnOwner: TObject;
FPDocFilename: String;
S2SItem: PStringToStringTreeItem;
S2SItem: PStringToStringItem;
begin
for S2SItem in SrcFilenames do begin
SrcFilename:=S2SItem^.Name;
@ -3171,7 +3174,7 @@ end;
procedure TCodeHelpManager.FreeDocs;
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
begin
AVLNode:=FDocs.FindLowest;
while AVLNode<>nil do begin

25
ide/codetoolsdefpreview.pas
View File

@ -30,10 +30,19 @@ unit CodeToolsDefPreview;
interface
uses
Classes, SysUtils, Math,
LCLProc, Forms, Controls, Graphics, Dialogs, ButtonPanel,
StdCtrls, Buttons, ComCtrls, ExtCtrls, LazFileUtils, AVGLvlTree,
SynEdit, DefineTemplates, ExprEval, IDEWindowIntf, IDEHelpIntf,
Classes, SysUtils, Math, Laz_AVL_Tree,
// LCL
LCLProc, Forms, Controls, Graphics, Dialogs, ButtonPanel, Buttons,
StdCtrls, ComCtrls, ExtCtrls,
// LazUtils
LazFileUtils,
// Codetools
DefineTemplates, ExprEval,
// SynEdit
SynEdit,
// IdeIntf
IDEWindowIntf, IDEHelpIntf,
// IDE
EditorOptions, LazarusIDEStrConsts, InputHistory, CodeToolsOptions, IDEProcs;
type
@ -79,7 +88,7 @@ type
{%H-}Selected: Boolean);
private
FDefineTree: TDefineTree;
FNodeValues: TAvgLvlTree;
FNodeValues: TAvlTree;
fReport: TStringList;
procedure SetDefineTree(const AValue: TDefineTree);
procedure UpdateValues;
@ -232,7 +241,7 @@ procedure TCodeToolsDefinesDialog.UpdateValues;
procedure AddNodeReport(Prefix: string; DefTempl: TDefineTemplate);
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
NodeValues: TCodeToolsDefinesNodeValues;
s: String;
begin
@ -356,7 +365,7 @@ var
SelTreeNode: TTreeNode;
SelDefNode: TDefineTemplate;
s: string;
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
NodeValues: TCodeToolsDefinesNodeValues;
begin
SelTreeNode:=ParsedTemplatesTreeView.Selected;
@ -427,7 +436,7 @@ begin
NewNodeValues.ExpressionResult:=ExpressionResult;
NewNodeValues.Execute:=Execute;
if FNodeValues=nil then
FNodeValues:=TAvgLvlTree.Create(@CompareNodeValues);
FNodeValues:=TAvlTree.Create(@CompareNodeValues);
FNodeValues.Add(NewNodeValues);
end;

34
ide/compileroptions.pp
View File

@ -42,11 +42,11 @@ unit CompilerOptions;
interface
uses
Classes, SysUtils,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
InterfaceBase, Forms, Controls, LCLProc,
// LazUtils
FileUtil, LazFileUtils, LazUTF8, AvgLvlTree, Laz2_XMLCfg, Laz2_DOM,
FileUtil, LazFileUtils, LazUTF8, Laz2_XMLCfg, Laz2_DOM,
// CodeTools
FileProcs, DefineTemplates, CodeToolsCfgScript, CodeToolManager,
KeywordFuncLists, BasicCodeTools,
@ -379,11 +379,11 @@ type
TCompilerMsgIDFlagsEnumerator = class
protected
FTree: TAvgLvlTree;
FCurrent: TAvgLvlTreeNode;
FTree: TAvlTree;
FCurrent: TAvlTreeNode;
function GetCurrent: PCompilerMsgIdFlag; inline;
public
constructor Create(Tree: TAvgLvlTree);
constructor Create(Tree: TAvlTree);
function GetEnumerator: TCompilerMsgIDFlagsEnumerator; inline;
function MoveNext: Boolean;
property Current: PCompilerMsgIdFlag read GetCurrent;
@ -395,8 +395,8 @@ type
private
FChangeStamp: int64;
fLastSavedStamp: int64;
fTree: TAvgLvlTree; // tree of TCompilerMsgIdFlag
function FindNode(MsgId: integer): TAvgLvlTreeNode;
fTree: TAvlTree; // tree of TCompilerMsgIdFlag
function FindNode(MsgId: integer): TAvlTreeNode;
protected
function GetValues(MsgId: integer): TCompilerFlagValue; override;
function GetModified: boolean; override;
@ -1012,7 +1012,7 @@ begin
Result:=PCompilerMsgIdFlag(FCurrent.Data);
end;
constructor TCompilerMsgIDFlagsEnumerator.Create(Tree: TAvgLvlTree);
constructor TCompilerMsgIDFlagsEnumerator.Create(Tree: TAvlTree);
begin
FTree:=Tree;
end;
@ -4611,7 +4611,7 @@ begin
Result:=fTree.Count;
end;
function TCompilerMsgIDFlags.FindNode(MsgId: integer): TAvgLvlTreeNode;
function TCompilerMsgIDFlags.FindNode(MsgId: integer): TAvlTreeNode;
var
Flag: TCompilerMsgIdFlag;
begin
@ -4621,7 +4621,7 @@ end;
function TCompilerMsgIDFlags.GetValues(MsgId: integer): TCompilerFlagValue;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
begin
Node:=FindNode(MsgId);
if Node<>nil then
@ -4646,7 +4646,7 @@ end;
procedure TCompilerMsgIDFlags.SetValues(MsgId: integer;
AValue: TCompilerFlagValue);
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Flag: PCompilerMsgIdFlag;
begin
Node:=FindNode(MsgId);
@ -4680,7 +4680,7 @@ end;
constructor TCompilerMsgIDFlags.Create;
begin
fTree:=TAvgLvlTree.Create(@CompareCompMsgIdFlag);
fTree:=TAvlTree.Create(@CompareCompMsgIdFlag);
end;
destructor TCompilerMsgIDFlags.Destroy;
@ -4692,7 +4692,7 @@ end;
procedure TCompilerMsgIDFlags.Clear;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Flag: PCompilerMsgIdFlag;
begin
Node:=fTree.FindLowest;
@ -4707,7 +4707,7 @@ end;
procedure TCompilerMsgIDFlags.Assign(Source: TPersistent);
var
Src: TCompilerMsgIDFlags;
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
SrcFlag, Flag: PCompilerMsgIdFlag;
begin
if Source is TCompilerMsgIDFlags then begin
@ -4735,8 +4735,8 @@ end;
function TCompilerMsgIDFlags.Equals(Obj: TObject): boolean;
var
Other: TCompilerMsgIDFlags;
MyNode: TAvgLvlTreeNode;
OtherNode: TAvgLvlTreeNode;
MyNode: TAvlTreeNode;
OtherNode: TAvlTreeNode;
MyFlag: PCompilerMsgIdFlag;
OtherFlag: PCompilerMsgIdFlag;
begin
@ -4791,7 +4791,7 @@ end;
function TCompilerMsgIDFlags.CreateDiff(Tool: TCompilerDiffTool;
Other: TCompilerMsgIDFlags): boolean;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Flag: PCompilerMsgIdFlag;
OtherFlag: TCompilerFlagValue;
begin

14
ide/componentpalette.pas
View File

@ -38,11 +38,15 @@ unit ComponentPalette;
interface
uses
Classes, SysUtils, AVL_Tree, fgl, LCLType,
Controls, Forms, Graphics, ComCtrls, Buttons, Menus, ExtCtrls,
LazFileUtils, LazFileCache, PropEdits, LCLProc, MainBase, LazarusIDEStrConsts,
FormEditingIntf, LazIDEIntf, IDEImagesIntf,
ComponentReg, DesignerProcs, PackageDefs, EnvironmentOpts;
Classes, SysUtils, fgl, Laz_AVL_Tree,
// LCL
LCLType, LCLProc, Controls, Forms, Graphics, ComCtrls, Buttons, Menus, ExtCtrls,
// LazUtils
LazFileUtils, LazFileCache,
// IdeIntf
FormEditingIntf, LazIDEIntf, IDEImagesIntf, PropEdits, ComponentReg,
// IDE
MainBase, LazarusIDEStrConsts, DesignerProcs, PackageDefs, EnvironmentOpts;
const
CompPalSelectionToolBtnPrefix = 'PaletteSelectBtn';

30
ide/customformeditor.pp
View File

@ -38,12 +38,13 @@ uses
{$IFDEF IDE_MEM_CHECK}
MemCheck,
{$ENDIF}
// LCL+FCL
Classes, SysUtils, TypInfo, Math,
// RTL+FCL
Classes, SysUtils, TypInfo, Math, Laz_AVL_Tree,
// LCL
LCLIntf, LCLType, LCLProc, LResources, LCLMemManager, Controls, Graphics,
Forms, Menus, Dialogs,
// LazUtils
FileUtil, LazFileUtils, LazFileCache, AvgLvlTree,
FileUtil, LazFileUtils, LazFileCache,
// Codetools
CodeCache, CodeTree, CodeToolManager, FindDeclarationTool,
// IDEIntf
@ -72,20 +73,20 @@ type
FOnSelectFrame: TSelectFrameEvent;
FSelection: TPersistentSelectionList;
FObj_Inspector: TObjectInspectorDlg;
FDefineProperties: TAvgLvlTree;// tree of TDefinePropertiesCacheItem
FDefineProperties: TAvlTree;// tree of TDefinePropertiesCacheItem
FStandardDefinePropertiesRegistered: Boolean;
FDesignerBaseClasses: TFPList; // list of TComponentClass
FDesignerMediatorClasses: TFPList;// list of TDesignerMediatorClass
FOnNodeGetImageIndex: TOnOINodeGetImageEvent;
function GetPropertyEditorHook: TPropertyEditorHook;
function FindDefinePropertyNode(const APersistentClassName: string
): TAvgLvlTreeNode;
): TAvlTreeNode;
procedure FrameCompGetCreationClass(Sender: TObject;
var NewComponentClass: TComponentClass);
function OnPropHookGetAncestorInstProp(const InstProp: TInstProp;
out AncestorInstProp: TInstProp): boolean;
protected
FNonFormForms: TAvgLvlTree; // tree of TNonControlDesignerForm sorted for LookupRoot
FNonFormForms: TAvlTree; // tree of TNonControlDesignerForm sorted for LookupRoot
procedure SetSelection(const ASelection: TPersistentSelectionList);
procedure OnObjectInspectorModified(Sender: TObject);
procedure SetObj_Inspector(AnObjectInspector: TObjectInspectorDlg); virtual;
@ -109,7 +110,7 @@ type
function GetStandardDesignerBaseClasses(Index: integer): TComponentClass; override;
procedure SetStandardDesignerBaseClasses(Index: integer; AValue: TComponentClass); override;
procedure OnDesignerMenuItemClick(Sender: TObject); virtual;
function FindNonFormFormNode(LookupRoot: TComponent): TAvgLvlTreeNode;
function FindNonFormFormNode(LookupRoot: TComponent): TAvlTreeNode;
//because we only meet ObjInspectore here, not in abstract ancestor
procedure DoOnNodeGetImageIndex(APersistent: TPersistent; var AImageIndex: integer); virtual;
@ -454,7 +455,7 @@ var
l: Integer;
begin
inherited Create;
FNonFormForms := TAvgLvlTree.Create(@CompareNonFormDesignerForms);
FNonFormForms := TAvlTree.Create(@CompareNonFormDesignerForms);
FSelection := TPersistentSelectionList.Create;
FDesignerBaseClasses:=TFPList.Create;
FDesignerMediatorClasses:=TFPList.Create;
@ -809,7 +810,7 @@ end;
function TCustomFormEditor.FindNonFormForm(LookupRoot: TComponent): TNonFormProxyDesignerForm;
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
begin
AVLNode := FindNonFormFormNode(LookupRoot);
if AVLNode <> nil then
@ -1739,7 +1740,7 @@ var
APersistent: TPersistent;
CacheItem: TDefinePropertiesCacheItem;
DefinePropertiesReader: TDefinePropertiesReader;
ANode: TAvgLvlTreeNode;
ANode: TAvlTreeNode;
OldClassName: String;
DefinePropertiesPersistent: TDefinePropertiesPersistent;
@ -1897,7 +1898,7 @@ end;
procedure TCustomFormEditor.RegisterDefineProperty(const APersistentClassName,
Identifier: string);
var
ANode: TAvgLvlTreeNode;
ANode: TAvlTreeNode;
CacheItem: TDefinePropertiesCacheItem;
begin
//DebugLn('TCustomFormEditor.RegisterDefineProperty ',APersistentClassName,' ',Identifier);
@ -2080,7 +2081,7 @@ begin
end;
end;
function TCustomFormEditor.FindNonFormFormNode(LookupRoot: TComponent): TAvgLvlTreeNode;
function TCustomFormEditor.FindNonFormFormNode(LookupRoot: TComponent): TAvlTreeNode;
begin
Result := FNonFormForms.FindKey(Pointer(LookupRoot),
@CompareLookupRootAndNonFormDesignerForm);
@ -2245,11 +2246,10 @@ begin
end;
function TCustomFormEditor.FindDefinePropertyNode(
const APersistentClassName: string): TAvgLvlTreeNode;
const APersistentClassName: string): TAvlTreeNode;
begin
if FDefineProperties=nil then
FDefineProperties:=
TAvgLvlTree.Create(TListSortCompare(@CompareDefPropCacheItems));
FDefineProperties:=TAvlTree.Create(TListSortCompare(@CompareDefPropCacheItems));
Result:=FDefineProperties.FindKey(PChar(APersistentClassName),
TListSortCompare(@ComparePersClassNameAndDefPropCacheItem));
end;

4
ide/etfpcmsgparser.pas
View File

@ -35,10 +35,10 @@ uses
// RTL
Classes, SysUtils, strutils, math,
// CodeTools
KeywordFuncLists, CodeToolsFPCMsgs, CodeToolsStructs, CodeCache, FileProcs,
KeywordFuncLists, CodeToolsFPCMsgs, {CodeToolsStructs,} CodeCache, FileProcs,
CodeToolManager, DirectoryCacher, BasicCodeTools, DefineTemplates, SourceLog,
// LazUtils
LConvEncoding, LazUTF8, FileUtil, LazFileUtils,
LConvEncoding, LazUTF8, FileUtil, LazFileUtils, AvgLvlTree,
// IDEIntf
IDEExternToolIntf, PackageIntf, LazIDEIntf, ProjectIntf, MacroIntf,
IDEUtils, LazFileCache,

2
ide/etmakemsgparser.pas
View File

@ -35,7 +35,7 @@ uses
// CodeTools
CodeToolsStructs, KeywordFuncLists,
// LazUtils
FileUtil, LazFileUtils,
FileUtil, LazFileUtils, AvgLvlTree,
// IDEIntf
IDEExternToolIntf;

19
ide/etmessageframe.pas
View File

@ -32,13 +32,14 @@ unit etMessageFrame;
interface
uses
Math, strutils, Classes, SysUtils,
UTF8Process, FileProcs, LazFileCache,
LazUTF8Classes, LazFileUtils, LazUTF8, AvgLvlTree, SynEdit,
LResources, Forms, Buttons, ExtCtrls, Controls, LMessages,
LCLType, Graphics, LCLIntf, Themes, ImgList, GraphType, Menus, Clipbrd,
Dialogs, StdCtrls,
SynEditMarks,
Math, strutils, Classes, SysUtils, Laz_AVL_Tree,
// LCL
Forms, Buttons, ExtCtrls, Controls, LMessages, LCLType, LCLIntf,
Graphics, Themes, ImgList, GraphType, Menus, Clipbrd, Dialogs, StdCtrls,
// LazUtils
UTF8Process, FileProcs, LazFileCache, LazUTF8Classes, LazFileUtils, LazUTF8,
// SynEdit
SynEdit, SynEditMarks,
// IDEIntf
IDEExternToolIntf, IDEImagesIntf, MenuIntf, PackageIntf,
IDECommands, IDEDialogs, ProjectIntf, CompOptsIntf, LazIDEIntf,
@ -878,7 +879,7 @@ function TLMsgWndView.ApplySrcChanges(Changes: TETSingleSrcChanges): boolean;
var
Queue: TETSingleSrcChanges;
Change: TETSrcChange;
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
aFilename: String;
begin
Result:=false;
@ -3550,7 +3551,7 @@ end;
procedure TMessagesFrame.ApplyMultiSrcChanges(Changes: TETMultiSrcChanges);
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
begin
for Node in Changes.PendingChanges do
ApplySrcChanges(TETSingleSrcChanges(Node.Data));

8
ide/etquickfixes.pas
View File

@ -53,7 +53,7 @@ unit etQuickFixes;
interface
uses
Classes, SysUtils,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
Menus, Dialogs, Controls,
// LazUtils
@ -925,11 +925,11 @@ var
end;
var
Tree: TAvgLvlTree;
Node: TAvgLvlTreeNode;
Tree: TAvlTree;
Node: TAvlTreeNode;
i: Integer;
begin
Tree:=TAvgLvlTree.Create(@CompareMsgLinesSrcPos);
Tree:=TAvlTree.Create(@CompareMsgLinesSrcPos);
try
// get all messages to hide and sort them for position
if Msg=nil then begin

21
ide/etsrceditmarks.pas
View File

@ -32,11 +32,11 @@ unit etSrcEditMarks;
interface
uses
Classes, SysUtils, math,
Classes, SysUtils, math, Laz_AVL_Tree,
// LCL
Graphics, Controls, Forms, ImgList,
// LazUtils
LazLogger, LazFileUtils, AvgLvlTree,
LazLogger, LazFileUtils,
// Codetools
KeywordFuncLists,
// SynEdit
@ -174,9 +174,9 @@ type
TETMultiSrcChanges = class(TComponent)
private
fAllChanges: TAvgLvlTree; // tree of TETSingleSrcChanges sorted for Filename
fAllChanges: TAvlTree; // tree of TETSingleSrcChanges sorted for Filename
FAutoSync: boolean;
fPendingChanges: TAvgLvlTree; // tree of TETSingleSrcChanges sorted for Filename
fPendingChanges: TAvlTree; // tree of TETSingleSrcChanges sorted for Filename
FOnSync: TNotifyEvent;
FSyncQueued: boolean;
procedure SetSyncQueued(AValue: boolean);
@ -191,8 +191,8 @@ type
function AdaptCaret(const aFilename: string; var Line,Col: integer;
LeftBound: boolean // true = position is bound to character on the left
): boolean;
property AllChanges: TAvgLvlTree read fAllChanges; // tree of TETSingleSrcChanges sorted for Filename
property PendingChanges: TAvgLvlTree read fPendingChanges; // tree of TETSingleSrcChanges sorted for Filename
property AllChanges: TAvlTree read fAllChanges; // tree of TETSingleSrcChanges sorted for Filename
property PendingChanges: TAvlTree read fPendingChanges; // tree of TETSingleSrcChanges sorted for Filename
property SyncQueued: boolean read FSyncQueued write SetSyncQueued;
property OnSync: TNotifyEvent read FOnSync write FOnSync; // called by Application.QueueAsyncCall
property AutoSync: boolean read FAutoSync write FAutoSync; // true = call OnSync via Application.QueueAsyncCall
@ -589,8 +589,7 @@ end;
procedure TETMultiSrcChanges.DoSync(Data: PtrInt);
var
Node: TAvgLvlTreeNode;
NextNode: TAvgLvlTreeNode;
Node, NextNode: TAvlTreeNode;
begin
//debugln(['TETMultiSrcChanges.DoSync Files=',fPendingChanges.Count]);
FSyncQueued:=false;
@ -611,8 +610,8 @@ end;
constructor TETMultiSrcChanges.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
fAllChanges:=TAvgLvlTree.Create(@CompareETSrcChangesFilenames);
fPendingChanges:=TAvgLvlTree.Create(@CompareETSrcChangesFilenames);
fAllChanges:=TAvlTree.Create(@CompareETSrcChangesFilenames);
fPendingChanges:=TAvlTree.Create(@CompareETSrcChangesFilenames);
end;
destructor TETMultiSrcChanges.Destroy;
@ -634,7 +633,7 @@ end;
function TETMultiSrcChanges.GetChanges(const aFilename: string;
CreateIfNotExists: boolean): TETSingleSrcChanges;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
begin
Node:=fAllChanges.FindKey(Pointer(aFilename),@CompareFilenameAndETSrcChanges);
if Node<>nil then

11
ide/extractprocdlg.pas
View File

@ -32,11 +32,14 @@ unit ExtractProcDlg;
interface
uses
Classes, SysUtils, LCLProc, AVL_Tree, Forms, Controls, Graphics,
Dialogs, ExtCtrls, Buttons, StdCtrls, ButtonPanel,
BasicCodeTools, CodeTree, CodeCache, CodeToolManager,
ExtractProcTool,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
Forms, Controls, Dialogs, ExtCtrls, StdCtrls, ButtonPanel, LCLProc,
// Codetools
BasicCodeTools, CodeTree, CodeCache, CodeToolManager, ExtractProcTool,
// IdeIntf
IDEHelpIntf, IDEDialogs,
// IDE
LazarusIDEStrConsts, IDEProcs, MiscOptions;
type

9
ide/exttools.pas
View File

@ -34,14 +34,15 @@ unit ExtTools;
interface
uses
// RTL + FCL + LCL
Classes, SysUtils, math, process, Pipes,
// RTL + FCL
Classes, SysUtils, math, process, Pipes, Laz_AVL_Tree,
// LCL
LCLIntf, Forms, Dialogs,
{$IFDEF VerboseExtToolThread}
LCLProc,
{$ENDIF}
// CodeTools
FileProcs, CodeToolsStructs,
FileProcs, //CodeToolsStructs,
// LazUtils
FileUtil, AvgLvlTree, LazFileUtils, UTF8Process, LazUTF8,
// IDEIntf
@ -982,7 +983,7 @@ var
end;
var
Node: TAvgLvlTreeNode;
Node: TAvlTreeNode;
Item: PPointerToPointerItem;
Info: PInfo;
begin

24
ide/filereferencelist.pas
View File

@ -38,7 +38,15 @@ unit FileReferenceList;
interface
uses
Classes, SysUtils, LCLProc, FileProcs, LazFileUtils, AvgLvlTree, IDEProcs;
Classes, SysUtils, Laz_AVL_Tree,
// LCL
LCLProc,
// Codetools
FileProcs,
// LazUtils
LazFileUtils,
// IDE
IDEProcs;
type
{ TFileReference }
@ -65,7 +73,7 @@ type
private
FOnChanged: TNotifyEvent;
FTimeStamp: integer;
FTree: TAvgLvlTree; // tree of TFileReference sorted for filename
FTree: TAvlTree; // tree of TFileReference sorted for filename
FFlags: TFileReferenceFlags;
FSearchPath: string;
FUpdateLock: integer;
@ -110,7 +118,7 @@ end;
procedure TFileReferenceList.UpdateSearchPath;
var
SearchPathLen: Integer;
ANode: TAvgLvlTreeNode;
ANode: TAvlTreeNode;
StartPos: Integer;
CurFileLen: Integer;
CurFileName: String;
@ -212,7 +220,7 @@ end;
procedure TFileReferenceList.AddFilename(const Filename: string);
var
ANode: TAvgLvlTreeNode;
ANode: TAvlTreeNode;
NewFileRef: TFileReference;
begin
if Filename='' then exit;
@ -226,14 +234,14 @@ begin
NewFileRef:=TFileReference.Create;
NewFileRef.fFilename:=Filename;
inc(NewFileRef.fReferenceCount);
if FTree=nil then FTree:=TAvgLvlTree.Create(@CompareFileReferences);
if FTree=nil then FTree:=TAvlTree.Create(@CompareFileReferences);
FTree.Add(NewFileRef);
Invalidate;
end;
procedure TFileReferenceList.RemoveFilename(const Filename: string);
var
ANode: TAvgLvlTreeNode;
ANode: TAvlTreeNode;
CurFileRef: TFileReference;
begin
if Filename='' then exit;
@ -251,7 +259,7 @@ end;
function TFileReferenceList.GetFileReference(const Filename: string): TFileReference;
var
ANode: TAvgLvlTreeNode;
ANode: TAvlTreeNode;
begin
Result:=nil;
if FTree=nil then exit;
@ -268,7 +276,7 @@ end;
function TFileReferenceList.CreateFileList: TStringList;
var
ANode: TAvgLvlTreeNode;
ANode: TAvlTreeNode;
begin
Result:=TStringList.Create;
if FTree=nil then exit;

23
ide/findoverloadsdlg.pas
View File

@ -37,11 +37,12 @@ unit FindOverloadsDlg;
interface
uses
Classes, SysUtils, LCLProc, LazFileUtils, Forms, Controls, Graphics,
Dialogs, ExtCtrls, StdCtrls, Buttons, ButtonPanel, ComCtrls, AvgLvlTree,
Classes, SysUtils, Laz_AVL_Tree,
// LCL
LCLProc, LazFileUtils, Forms, Controls, StdCtrls, ButtonPanel, ComCtrls,
// codetools
FindDeclarationTool, PascalParserTool, CodeTree, CodeCache,
CodeToolManager, FindOverloads,
FindDeclarationTool, PascalParserTool, CodeTree, CodeCache, CodeToolManager,
FindOverloads,
// IDE
LazIDEIntf, ProjectIntf, SrcEditorIntf, IDEProcs;
@ -82,8 +83,8 @@ type
TFindOverloadsWorker = class
private
FFiles: TAvgLvlTree;
FScanFiles: TAvgLvlTree;
FFiles: TAvlTree;
FScanFiles: TAvlTree;
FStagePosition: integer;
FStagePosMax: integer;
FStageTitle: string;
@ -107,8 +108,8 @@ type
function AddFileToScan(const Filename: string;
CheckExtension: boolean = true): TFOWFile;
function FindFile(const Filename: string): TFOWFile;
property Files: TAvgLvlTree read FFiles; // tree of TFindOverloadsWorkerFile
property ScanFiles: TAvgLvlTree read FScanFiles;// tree of TFindOverloadsWorkerFile
property Files: TAvlTree read FFiles; // tree of TFindOverloadsWorkerFile
property ScanFiles: TAvlTree read FScanFiles;// tree of TFindOverloadsWorkerFile
property StageTitle: string read FStageTitle write FStageTitle;
property StagePosition: integer read FStagePosition write FStagePosition;
property StagePosMax: integer read FStagePosMax write FStagePosMax;
@ -481,7 +482,7 @@ end;
function TFindOverloadsWorker.FindFile(const Filename: string): TFOWFile;
var
AVLNode: TAvgLvlTreeNode;
AVLNode: TAvlTreeNode;
begin
AVLNode:=FFiles.FindKey(Pointer(Filename),@CompareFilenameWithFOWFile);
if AVLNode<>nil then
@ -493,8 +494,8 @@ end;
constructor TFindOverloadsWorker.Create;
begin
Scopes:=[fosProject,fosPackages];
FFiles:=TAvgLvlTree.Create(TListSortCompare(@CompareFOWFiles));
FScanFiles:=TAvgLvlTree.Create(TListSortCompare(@CompareFOWFiles));
FFiles:=TAvlTree.Create(TListSortCompare(@CompareFOWFiles));
FScanFiles:=TAvlTree.Create(TListSortCompare(@CompareFOWFiles));
FStagePosMax:=100;
end;

Some files were not shown because too many files have changed in this diff Show More