mirror of
https://gitlab.com/freepascal.org/lazarus/lazarus.git
synced 2025-07-18 17:26:22 +02:00
4902 lines
226 KiB
ObjectPascal
4902 lines
226 KiB
ObjectPascal
unit TestHighlightPas;
|
|
|
|
{$mode objfpc}{$H+}
|
|
|
|
interface
|
|
|
|
uses
|
|
Classes, SysUtils, testregistry, TestBase, Forms, LazLoggerBase,
|
|
TestHighlightFoldBase, SynEdit, SynEditTypes, SynHighlighterPas,
|
|
SynEditHighlighterFoldBase, SynEditHighlighter;
|
|
|
|
type
|
|
|
|
// used by Fold / MarkupWord
|
|
|
|
{ TTestBaseHighlighterPas }
|
|
|
|
TTestBaseHighlighterPas = class(TTestBaseHighlighterFoldBase)
|
|
protected
|
|
FKeepAllModifierAttribs: boolean;
|
|
function PasHighLighter: TSynPasSyn;
|
|
function CreateTheHighLighter: TSynCustomFoldHighlighter; override;
|
|
procedure InitTighLighterAttr; override;
|
|
procedure EnableFolds(AEnbledTypes: TPascalCodeFoldBlockTypes;
|
|
AHideTypes: TPascalCodeFoldBlockTypes = [];
|
|
ANoFoldTypes: TPascalCodeFoldBlockTypes = []
|
|
);
|
|
procedure DebugFoldInfo(ALineIdx: Integer; AFilter: TSynFoldActions; Group: Integer=0);
|
|
procedure DebugFoldInfo(AFilter: TSynFoldActions; Group: Integer=0);
|
|
function FoldActionsToString(AFoldActions: TSynFoldActions): String;
|
|
Procedure CheckPasFoldNodeInfo(AName: String; nd: TSynFoldNodeInfo;
|
|
ALine: TLineIdx; AColumn, AAllColIndex: integer; LogXStart, LogXEnd,
|
|
FoldLvlStart, FoldLvlEnd, NestLvlStart, NestLvlEnd: Integer;
|
|
FoldType, FoldTypeCompatible: TPascalCodeFoldBlockType; FoldGroup: Integer;
|
|
FoldAction: TSynFoldActions);
|
|
Procedure CheckPasFoldNodeInfo(AName: String; nd: TSynFoldNodeInfo;
|
|
ALine: TLineIdx; AColumn: integer; LogXStart, LogXEnd,
|
|
FoldLvlStart, FoldLvlEnd, NestLvlStart, NestLvlEnd: Integer;
|
|
FoldType, FoldTypeCompatible: TPascalCodeFoldBlockType; FoldGroup: Integer;
|
|
FoldAction: TSynFoldActions);
|
|
end;
|
|
|
|
{ TTestHighlighterPas }
|
|
|
|
TTestHighlighterPas = class(TTestBaseHighlighterPas)
|
|
protected
|
|
FAttrProcName: TSynHighlighterAttributesModifier;
|
|
FCaseLabelAttri: TSynHighlighterAttributesModifier;
|
|
procedure ReCreateEdit; override;
|
|
|
|
function TestTextFoldInfo1: TStringArray;
|
|
function TestTextFoldInfo2: TStringArray;
|
|
function TestTextFoldInfo3: TStringArray;
|
|
function TestTextFoldInfo4(AIfCol: Integer): TStringArray;
|
|
function TestTextFoldInfo5: TStringArray;
|
|
procedure CheckTokensForLine(Name: String; LineIdx: Integer; ExpTokens: Array of TExpTokenInfo); reintroduce;
|
|
|
|
published
|
|
procedure TestFoldInfo;
|
|
procedure TestExtendedKeywordsAndStrings;
|
|
procedure TestRaiseAt;
|
|
procedure TestContextForProcModifiers;
|
|
procedure TestContextForProcModifiers2;
|
|
procedure TestContextForProcModifiersName;
|
|
procedure TestContextForVarModifiers;
|
|
procedure TestContextForVarModifiers2;
|
|
procedure TestContextForProperties;
|
|
procedure TestContextForProcedure;
|
|
procedure TestContextForProcedureNameAttr;
|
|
procedure TestContextForInterface;
|
|
procedure TestContextForDeprecated;
|
|
procedure TestContextForClassObjRecHelp;
|
|
procedure TestContextForClassSection;
|
|
procedure TestContextForClassModifier; // Sealed abstract
|
|
procedure TestContextForClassOf;
|
|
procedure TestContextForClassProcModifier; // virtual override final reintroduce
|
|
procedure TestContextForClassHelper;
|
|
procedure TestContextForTypeHelper;
|
|
procedure TestContextForClassFunction; // in class,object,record
|
|
procedure TestContextForRecordHelper;
|
|
procedure TestContextForRecordCase;
|
|
procedure TestContextForStatic;
|
|
procedure TestCaseLabel;
|
|
procedure TestModifierAttributesForProcedure;
|
|
procedure TestModifierAttributesForProperty;
|
|
procedure TestModifierAttributesForVarConstType;
|
|
procedure TestModifierAttributesWithAnonProcedure;
|
|
procedure TestModifierAttributesForLabel;
|
|
procedure TestCaretAsString;
|
|
procedure TestFoldNodeInfo;
|
|
end;
|
|
|
|
implementation
|
|
|
|
const
|
|
TK_Comma = tkSymbol;
|
|
TK_Semi = tkSymbol;
|
|
TK_Dot = tkSymbol;
|
|
TK_Colon = tkSymbol;
|
|
TK_Equal = tkSymbol;
|
|
TK_Bracket = tkSymbol;
|
|
|
|
type
|
|
TNoMergedTokenAttriIndicator = (PlainAttr);
|
|
|
|
operator := (a: TtkTokenKind) : TExpTokenInfo;
|
|
begin
|
|
result := default(TExpTokenInfo);
|
|
result.ExpKind := ord(a);
|
|
result.Flags := [etiKind];
|
|
end;
|
|
|
|
operator + (a: TtkTokenKind; b: TSynHighlighterAttributes) : TExpTokenInfo;
|
|
begin
|
|
result := default(TExpTokenInfo);
|
|
result.ExpKind := ord(a);
|
|
result.ExpAttr := b;
|
|
result.Flags := [etiKind, etiAttr];
|
|
end;
|
|
|
|
{ TTestBaseHighlighterPas }
|
|
|
|
function TTestBaseHighlighterPas.PasHighLighter: TSynPasSyn;
|
|
begin
|
|
Result := TSynPasSyn(FTheHighLighter);
|
|
end;
|
|
|
|
function TTestBaseHighlighterPas.CreateTheHighLighter: TSynCustomFoldHighlighter;
|
|
begin
|
|
Result := TSynPasSyn.Create(nil);
|
|
end;
|
|
|
|
procedure TTestBaseHighlighterPas.InitTighLighterAttr;
|
|
begin
|
|
inherited InitTighLighterAttr;
|
|
|
|
PasHighLighter.CommentAnsiAttri.Clear;
|
|
PasHighLighter.CommentCurlyAttri.Clear;
|
|
PasHighLighter.CommentSlashAttri.Clear;
|
|
|
|
if FKeepAllModifierAttribs then exit;
|
|
|
|
PasHighLighter.PropertyNameAttr.Clear;
|
|
PasHighLighter.ProcedureHeaderParamAttr.Clear;
|
|
PasHighLighter.ProcedureHeaderTypeAttr.Clear;
|
|
PasHighLighter.ProcedureHeaderValueAttr.Clear;
|
|
PasHighLighter.ProcedureHeaderResultAttr.Clear;
|
|
PasHighLighter.DeclarationVarConstNameAttr.Clear;
|
|
PasHighLighter.DeclarationTypeNameAttr.Clear;
|
|
PasHighLighter.DeclarationTypeAttr.Clear;
|
|
PasHighLighter.DeclarationValueAttr.Clear;
|
|
PasHighLighter.GotoLabelAttr.Clear;
|
|
PasHighLighter.StructMemberAttr.Clear;
|
|
end;
|
|
|
|
procedure TTestBaseHighlighterPas.EnableFolds(AEnbledTypes: TPascalCodeFoldBlockTypes;
|
|
AHideTypes: TPascalCodeFoldBlockTypes; ANoFoldTypes: TPascalCodeFoldBlockTypes);
|
|
var
|
|
i: TPascalCodeFoldBlockType;
|
|
begin
|
|
PasHighLighter.BeginUpdate;
|
|
for i := low(TPascalCodeFoldBlockType) to high(TPascalCodeFoldBlockType) do begin
|
|
PasHighLighter.FoldConfig[ord(i)].Enabled := i in AEnbledTypes;
|
|
if (i in ANoFoldTypes) then
|
|
PasHighLighter.FoldConfig[ord(i)].Modes := []
|
|
else
|
|
PasHighLighter.FoldConfig[ord(i)].Modes := [fmFold];
|
|
if i in AHideTypes then
|
|
PasHighLighter.FoldConfig[ord(i)].Modes := PasHighLighter.FoldConfig[ord(i)].Modes + [fmHide];
|
|
|
|
PasHighLighter.FoldConfig[ord(i)].Modes := PasHighLighter.FoldConfig[ord(i)].Modes +
|
|
PasHighLighter.FoldConfig[ord(i)].SupportedModes * [fmMarkup];
|
|
end;
|
|
PasHighLighter.EndUpdate;
|
|
end;
|
|
|
|
procedure TTestBaseHighlighterPas.DebugFoldInfo(ALineIdx: Integer;
|
|
AFilter: TSynFoldActions; Group: Integer=0);
|
|
var
|
|
i, c: LongInt;
|
|
n: TSynFoldNodeInfo;
|
|
l: TLazSynFoldNodeInfoList;
|
|
begin
|
|
l := PasHighLighter.FoldNodeInfo[ALineIdx];
|
|
c := PasHighLighter.FoldNodeInfo[ALineIdx].CountEx(AFilter, Group);
|
|
l.ClearFilter;
|
|
l.ActionFilter := AFilter;
|
|
l.GroupFilter := Group;
|
|
debugln(['### Foldinfo Line: ', ALineIdx,
|
|
' Cnt=', l.Count, ' CntEx=', c,
|
|
' PasMinLvl=', PasHighLighter.FoldBlockMinLevel(ALineIdx,1),
|
|
' EndLvl=',PasHighLighter.FoldBlockEndLevel(ALineIdx,1),
|
|
//' Nestcnt=',PasHighLighter.FoldNestCount(ALineIdx,1),
|
|
' : ', copy(SynEdit.Lines[ALineIdx],1,40)]);
|
|
debugln('Idx: LogXStart End FldLvlStart End NestLvlStart End FldType FldTypeCompat FldGroup FldAction');
|
|
for i := 0 to c-1 do begin
|
|
n := l.NodeInfoEx(i, AFilter, Group);
|
|
if sfaInvalid in n.FoldAction then
|
|
debugln(Format('%3d %9d %3d %11d %3d %12d %3d %7d %13d %8d %s',
|
|
[i, 0,0, 0,0, 0,0, 0, 0, 0, FoldActionsToString(n.FoldAction)]))
|
|
else
|
|
debugln(Format('%3d %9d %3d %11d %3d %12d %3d %7d %13d %8d %s // %s',
|
|
[i, n.LogXStart, n.LogXEnd,
|
|
n.FoldLvlStart, n.FoldLvlEnd, n.NestLvlStart, n.NestLvlEnd,
|
|
PtrUInt(n.FoldType), PtrUInt(n.FoldTypeCompatible), n.FoldGroup,
|
|
FoldActionsToString(n.FoldAction),
|
|
copy(SynEdit.Lines[ALineIdx],n.LogXStart, n.LogXEnd-n.LogXStart+1)
|
|
]));
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBaseHighlighterPas.DebugFoldInfo(AFilter: TSynFoldActions;
|
|
Group: Integer=0);
|
|
var
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to SynEdit.Lines.Count - 1 do
|
|
DebugFoldInfo(i, AFilter, Group);
|
|
end;
|
|
|
|
function TTestBaseHighlighterPas.FoldActionsToString(
|
|
AFoldActions: TSynFoldActions): String;
|
|
var
|
|
s: string;
|
|
i: TSynFoldAction;
|
|
begin
|
|
Result:='';
|
|
for i := low(TSynFoldAction) to high(TSynFoldAction) do
|
|
if i in AFoldActions then begin
|
|
WriteStr(s, i);
|
|
Result := Result + s + ',';
|
|
end;
|
|
if Result <> '' then SetLength(Result, Length(Result)-1);
|
|
end;
|
|
|
|
procedure TTestBaseHighlighterPas.CheckPasFoldNodeInfo(AName: String; nd: TSynFoldNodeInfo;
|
|
ALine: TLineIdx; AColumn, AAllColIndex: integer; LogXStart, LogXEnd, FoldLvlStart,
|
|
FoldLvlEnd, NestLvlStart, NestLvlEnd: Integer; FoldType,
|
|
FoldTypeCompatible: TPascalCodeFoldBlockType; FoldGroup: Integer;
|
|
FoldAction: TSynFoldActions);
|
|
begin
|
|
AName := BaseTestName + AName;
|
|
AssertEquals(Format('%s (%d/%d) LineIndex', [AName, ALine, AColumn]), ALine, nd.LineIndex);
|
|
AssertEquals(Format('%s (%d/%d) NodeIndex', [AName, ALine, AColumn]), AColumn, nd.NodeIndex);
|
|
if AAllColIndex >= 0 then
|
|
AssertEquals(Format('%s (%d/%d) NodeIndex', [AName, ALine, AColumn]), AAllColIndex, nd.AllNodeIndex);
|
|
if not(sfaInvalid in nd.FoldAction) then begin
|
|
AssertEquals(Format('%s (%d/%d) LogXStart', [AName, ALine, AColumn]), LogXStart, nd.LogXStart);
|
|
AssertEquals(Format('%s (%d/%d) LogXEnd', [AName, ALine, AColumn]), LogXEnd, nd.LogXEnd);
|
|
if FoldLvlStart >= 0 then
|
|
AssertEquals(Format('%s (%d/%d) FoldLvlStart', [AName, ALine, AColumn]), FoldLvlStart, nd.FoldLvlStart);
|
|
if FoldLvlEnd >= 0 then
|
|
AssertEquals(Format('%s (%d/%d) FoldLvlEnd', [AName, ALine, AColumn]), FoldLvlEnd, nd.FoldLvlEnd);
|
|
AssertEquals(Format('%s (%d/%d) NestLvlStart', [AName, ALine, AColumn]), NestLvlStart, nd.NestLvlStart);
|
|
AssertEquals(Format('%s (%d/%d) NestLvlEnd', [AName, ALine, AColumn]), NestLvlEnd, nd.NestLvlEnd);
|
|
AssertEquals(Format('%s (%d/%d) FoldType', [AName, ALine, AColumn]), PtrInt(FoldType), PtrInt(nd.FoldType));
|
|
AssertEquals(Format('%s (%d/%d) FoldTypeCompatible', [AName, ALine, AColumn]),
|
|
PtrInt(FoldTypeCompatible), PtrInt(nd.FoldTypeCompatible));
|
|
AssertEquals(Format('%s (%d/%d) FoldGroup:', [AName, ALine, AColumn]), FoldGroup, nd.FoldGroup);
|
|
end;
|
|
AssertEquals(Format('%s (%d/%d) FoldAction', [AName, ALine, AColumn]),
|
|
FoldActionsToString(FoldAction),
|
|
FoldActionsToString(nd.FoldAction - [sfaOutline..sfaOutlineNoLine]));
|
|
end;
|
|
|
|
procedure TTestBaseHighlighterPas.CheckPasFoldNodeInfo(AName: String; nd: TSynFoldNodeInfo;
|
|
ALine: TLineIdx; AColumn: integer; LogXStart, LogXEnd, FoldLvlStart, FoldLvlEnd,
|
|
NestLvlStart, NestLvlEnd: Integer; FoldType, FoldTypeCompatible: TPascalCodeFoldBlockType;
|
|
FoldGroup: Integer; FoldAction: TSynFoldActions);
|
|
begin
|
|
CheckPasFoldNodeInfo(AName, nd, ALine, AColumn, -1, LogXStart, LogXEnd,
|
|
FoldLvlStart, FoldLvlEnd, NestLvlStart, NestLvlEnd, FoldType, FoldTypeCompatible,
|
|
FoldGroup, FoldAction);
|
|
end;
|
|
|
|
{ TTestHighlighterPas }
|
|
|
|
procedure TTestHighlighterPas.ReCreateEdit;
|
|
begin
|
|
inherited ReCreateEdit;
|
|
FAttrProcName := PasHighLighter.ProcedureHeaderName;
|
|
FCaseLabelAttri := PasHighLighter.CaseLabelAttri;
|
|
end;
|
|
|
|
function TTestHighlighterPas.TestTextFoldInfo1: TStringArray;
|
|
begin
|
|
SetLength(Result, 13);
|
|
Result[0] := 'program Foo;';
|
|
Result[1] := 'procedure a;';
|
|
Result[2] := '{$IFDEF A}';
|
|
Result[3] := 'begin';
|
|
Result[4] := '{$ENDIF}';
|
|
Result[5] := ' {$IFDEF B} with a do begin {$ENDIF}';
|
|
Result[6] := ' writeln()';
|
|
Result[7] := ' end;';
|
|
Result[8] := 'end;';
|
|
Result[9] := 'begin';
|
|
Result[10]:= 'end.';
|
|
Result[11]:= '//';
|
|
Result[12]:= '';
|
|
end;
|
|
|
|
function TTestHighlighterPas.TestTextFoldInfo2: TStringArray;
|
|
begin
|
|
// mix folds and same-line-closing
|
|
SetLength(Result, 9);
|
|
Result[0] := 'program Foo;';
|
|
Result[1] := 'procedure a;';
|
|
Result[2] := '{$IFDEF A} begin {$IFDEF B} repeat a; {$ENDIF} until b; {$IFDEF c} try {$ELSE} //x';
|
|
Result[3] := ' //foo';
|
|
Result[4] := ' finally repeat x; {$ENDIF C} until y;';
|
|
Result[5] := ' repeat m; until n; end; {$ENDIF A} // end finally';
|
|
Result[6] := 'end';
|
|
Result[7] := 'begin end.';
|
|
Result[8] := '';
|
|
|
|
end;
|
|
|
|
function TTestHighlighterPas.TestTextFoldInfo3: TStringArray;
|
|
begin
|
|
SetLength(Result, 12);
|
|
Result[0] := 'Unit Foo;';
|
|
Result[1] := 'Interface';
|
|
Result[2] := 'type a=Integer;';
|
|
Result[3] := 'var';
|
|
Result[4] := ' b:Integer';
|
|
Result[5] := 'const';
|
|
Result[6] := ' c = 1;';
|
|
Result[7] := ' d = 2; {$IFDEF A}';
|
|
Result[8] := 'Implementation';
|
|
Result[9] := '//';
|
|
Result[10]:= 'end.';
|
|
Result[11]:= '';
|
|
end;
|
|
|
|
function TTestHighlighterPas.TestTextFoldInfo4(AIfCol: Integer): TStringArray;
|
|
begin
|
|
// various mixed of pascal and ifdef blocks => actually a test for pascal highlighter
|
|
SetLength(Result, 8);
|
|
Result[0] := 'program p;';
|
|
Result[1] := 'procedure A;';
|
|
case AIfCol of
|
|
0: Result[2] := '{$IFDEF} begin with a do begin';
|
|
1: Result[2] := 'begin {$IFDEF} with a do begin';
|
|
2: Result[2] := 'begin with a do begin {$IFDEF}';
|
|
end;
|
|
Result[3] := ' end; // 2';
|
|
Result[4] := 'end; // 1';
|
|
Result[5] := '{$ENDIF}';
|
|
Result[6] := '//';
|
|
Result[7] := ''; // program fold is open end
|
|
|
|
end;
|
|
|
|
function TTestHighlighterPas.TestTextFoldInfo5: TStringArray;
|
|
begin
|
|
SetLength(Result, 13);
|
|
Result[0] := 'Unit Foo;';
|
|
Result[1] := 'Interface';
|
|
Result[2] := 'type';
|
|
Result[3] := 'TFoo<T: class> = class(TBar<T>)';
|
|
Result[4] := 'class procedure Proc;';
|
|
Result[5] := 'end;';
|
|
Result[6] := 'TFoo = record';
|
|
Result[7] := 'class procedure Proc;';
|
|
Result[8] := 'end;';
|
|
Result[9] := 'Implementation';
|
|
Result[10] := '//';
|
|
Result[11] := 'end.';
|
|
Result[12] := '';
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.CheckTokensForLine(Name: String;
|
|
LineIdx: Integer; ExpTokens: array of TExpTokenInfo);
|
|
var
|
|
i: Integer;
|
|
begin
|
|
for i := low(ExpTokens) to high(ExpTokens) do begin
|
|
if ExpTokens[i].Flags * [etiAttr, etiKind] = [etiKind] then begin
|
|
case TtkTokenKind(ExpTokens[i].ExpKind) of
|
|
tkIdentifier: ExpTokens[i].ExpAttr := PasHighLighter.IdentifierAttri;
|
|
tkKey: ExpTokens[i].ExpAttr := PasHighLighter.KeywordAttribute;
|
|
tkModifier: ExpTokens[i].ExpAttr := PasHighLighter.ModifierAttri;
|
|
tkSymbol: ExpTokens[i].ExpAttr := PasHighLighter.SymbolAttri;
|
|
tkString: ExpTokens[i].ExpAttr := PasHighLighter.StringAttri;
|
|
tkNumber: ExpTokens[i].ExpAttr := PasHighLighter.NumberAttri;
|
|
tkSpace: ExpTokens[i].ExpAttr := PasHighLighter.SpaceAttri;
|
|
tkComment: ExpTokens[i].ExpAttr := PasHighLighter.CommentAttri;
|
|
else ExpTokens[i].ExpAttr := nil;
|
|
end;
|
|
if ExpTokens[i].ExpAttr <> nil then
|
|
ExpTokens[i].Flags := ExpTokens[i].Flags + [etiAttr];
|
|
end;
|
|
end;
|
|
inherited CheckTokensForLine(Name, LineIdx, ExpTokens);
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestFoldInfo;
|
|
begin
|
|
ReCreateEdit;
|
|
|
|
// DebugFoldInfo([]);
|
|
|
|
{%region}
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]);
|
|
PushBaseName('Text 1 all folds');
|
|
|
|
AssertEquals('Len Prog', 10, PasHighLighter.FoldLineLength(0,0));
|
|
AssertEquals('Len Proc', 7, PasHighLighter.FoldLineLength(1,0));
|
|
AssertEquals('Len IF A', 2, PasHighLighter.FoldLineLength(2,0));
|
|
AssertEquals('Len Begin', 5, PasHighLighter.FoldLineLength(3,0));
|
|
AssertEquals('Len if beg', 2, PasHighLighter.FoldLineLength(5,0));
|
|
AssertEquals('Len PrgBeg', 1, PasHighLighter.FoldLineLength(9,0));
|
|
|
|
AssertEquals('Len invalid', -1, PasHighLighter.FoldLineLength(4,0)); // endif
|
|
AssertEquals('Len // (no hide)', -1, PasHighLighter.FoldLineLength(11,0));
|
|
|
|
// Pg pc $I bg $E be w e e be e //
|
|
CheckFoldOpenCounts('', [1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0]);
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaFold],
|
|
[1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0]);
|
|
|
|
EnableFolds([cfbtBeginEnd..cfbtNone], [cfbtSlashComment]);
|
|
AssertEquals('Len // (with hide)', 0, PasHighLighter.FoldLineLength(11,0));
|
|
|
|
// Pg pc $I bg $E be w e e be e //
|
|
CheckFoldOpenCounts('', [1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0]); // TODO: does not include the //
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaFold], // includes the //
|
|
[1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1]);
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaFold, sfaFoldFold],
|
|
[1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0]);
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaOneLineOpen, sfaFold, sfaFoldHide],
|
|
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
|
|
{%endregion}
|
|
|
|
{%region}
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtBeginEnd]);
|
|
PopPushBaseName('Text 1 all folds, except cfbtBeginEnd');
|
|
|
|
AssertEquals('Len Prog', 10, PasHighLighter.FoldLineLength(0,0));
|
|
AssertEquals('Len Proc', 7, PasHighLighter.FoldLineLength(1,0));
|
|
AssertEquals('Len IF A', 2, PasHighLighter.FoldLineLength(2,0));
|
|
AssertEquals('Len Begin', 5, PasHighLighter.FoldLineLength(3,0));
|
|
AssertEquals('Len if beg (not avail)', -1, PasHighLighter.FoldLineLength(5,0));
|
|
//AssertEquals('Len PrgBeg', 1, PasHighLighter.FoldLineLength(9,0));
|
|
|
|
AssertEquals('Len invalid', -1, PasHighLighter.FoldLineLength(4,0)); // endif
|
|
AssertEquals('Len // (no hide)', -1, PasHighLighter.FoldLineLength(11,0));
|
|
|
|
// Pg pc $I bg $E be w e e be e //
|
|
CheckFoldOpenCounts('', [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]);
|
|
{%endregion}
|
|
|
|
{%region}
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtBeginEnd,cfbtTopBeginEnd]);
|
|
PopPushBaseName('Text 1 all folds, except cfbtBeginEnd,cfbtTopBeginEnd');
|
|
|
|
AssertEquals('Len Prog', 10, PasHighLighter.FoldLineLength(0,0));
|
|
AssertEquals('Len Proc', 7, PasHighLighter.FoldLineLength(1,0));
|
|
AssertEquals('Len IF A', 2, PasHighLighter.FoldLineLength(2,0));
|
|
AssertEquals('Len Begin (not avail)', -1, PasHighLighter.FoldLineLength(3,0));
|
|
AssertEquals('Len if beg (not avail)', -1, PasHighLighter.FoldLineLength(5,0));
|
|
//AssertEquals('Len PrgBeg', 1, PasHighLighter.FoldLineLength(9,0));
|
|
|
|
AssertEquals('Len // (no hide)', -1, PasHighLighter.FoldLineLength(11,0));
|
|
|
|
// Pg pc $I bg $E be w e e be e //
|
|
CheckFoldOpenCounts('', [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
|
|
{%endregion}
|
|
|
|
|
|
|
|
{%region}
|
|
SetLines(TestTextFoldInfo2);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtRepeat], [cfbtSlashComment]);
|
|
PopPushBaseName('Text 2 all folds except repeat');
|
|
|
|
AssertEquals('Len Prog', 7, PasHighLighter.FoldLineLength(0,0));
|
|
AssertEquals('Len Proc', 5, PasHighLighter.FoldLineLength(1,0));
|
|
|
|
AssertEquals('Len IFDEF A', 3, PasHighLighter.FoldLineLength(2,0));
|
|
AssertEquals('Len Begin', 4, PasHighLighter.FoldLineLength(2,1));
|
|
AssertEquals('Len Try', 3, PasHighLighter.FoldLineLength(2,2));
|
|
AssertEquals('Len ELSE C', 2, PasHighLighter.FoldLineLength(2,3));
|
|
|
|
AssertEquals('Len //', 0, PasHighLighter.FoldLineLength(3,0));
|
|
AssertEquals('Finally', 1, PasHighLighter.FoldLineLength(4,0));
|
|
|
|
AssertEquals('Len invalid begin end', -1, PasHighLighter.FoldLineLength(7,0));
|
|
|
|
// Pg pc 4 // fi e e be-
|
|
CheckFoldOpenCounts('', [1, 1, 4, 0, 1, 0, 0, 0]);
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaFold],
|
|
[1, 1, 4, 1, 1, 0, 0, 0]);
|
|
{%endregion}
|
|
|
|
{%region}
|
|
SetLines(TestTextFoldInfo3);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone], [cfbtSlashComment]);
|
|
PushBaseName('Text 3 (end-last-line)');
|
|
|
|
AssertEquals('Len Unit', 10, PasHighLighter.FoldLineLength(0,0));
|
|
AssertEquals('Len Intf', 6, PasHighLighter.FoldLineLength(1,0));
|
|
AssertEquals('Len type(non)',-1, PasHighLighter.FoldLineLength(2,0));
|
|
AssertEquals('Len var', 1, PasHighLighter.FoldLineLength(3,0));
|
|
AssertEquals('Len const', 2, PasHighLighter.FoldLineLength(5,0));
|
|
AssertEquals('Len Impl', 1, PasHighLighter.FoldLineLength(8,0));
|
|
AssertEquals('Len //', 0, PasHighLighter.FoldLineLength(9,0));
|
|
|
|
// Un If ty va - co - $ Im // e
|
|
CheckFoldOpenCounts('', [1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0]);
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaFold],
|
|
[1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0]);
|
|
CheckFoldInfoCounts('', [sfaCloseFold, sfaFold, sfaLastLineClose],
|
|
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
|
|
CheckFoldInfoCounts('', [sfaLastLineClose],
|
|
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
|
|
{%endregion}
|
|
|
|
{%region}
|
|
SetLines(TestTextFoldInfo4(0));
|
|
EnableFolds([cfbtBeginEnd..cfbtNone], [cfbtSlashComment]);
|
|
PushBaseName('Text 4 (mixed group) 0');
|
|
|
|
AssertEquals('Len Prog', 6, PasHighLighter.FoldLineLength(0,0));
|
|
AssertEquals('Len Proc', 3, PasHighLighter.FoldLineLength(1,0));
|
|
AssertEquals('Len IF', 3, PasHighLighter.FoldLineLength(2,0));
|
|
AssertEquals('Len beg 1', 2, PasHighLighter.FoldLineLength(2,1));
|
|
AssertEquals('Len beg 2', 1, PasHighLighter.FoldLineLength(2,2));
|
|
AssertEquals('Len //', 0, PasHighLighter.FoldLineLength(6,0));
|
|
|
|
// Pg Pc 3 e e $e //
|
|
CheckFoldOpenCounts('', [1, 1, 3, 0, 0, 0, 0]);
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaFold],
|
|
[1, 1, 3, 0, 0, 0, 1]);
|
|
CheckFoldInfoCounts('', [sfaCloseFold, sfaFold, sfaLastLineClose],
|
|
[0, 0, 0, 0, 0, 0, 2]);
|
|
CheckFoldInfoCounts('', [sfaLastLineClose],
|
|
[0, 0, 0, 0, 0, 0, 2]);
|
|
|
|
|
|
SetLines(TestTextFoldInfo4(1));
|
|
EnableFolds([cfbtBeginEnd..cfbtNone], [cfbtSlashComment]);
|
|
PushBaseName('Text 4 (mixed group) 1');
|
|
|
|
AssertEquals('Len Prog', 6, PasHighLighter.FoldLineLength(0,0));
|
|
AssertEquals('Len Proc', 3, PasHighLighter.FoldLineLength(1,0));
|
|
AssertEquals('Len IF', 3, PasHighLighter.FoldLineLength(2,1));
|
|
AssertEquals('Len beg 1', 2, PasHighLighter.FoldLineLength(2,0));
|
|
AssertEquals('Len beg 2', 1, PasHighLighter.FoldLineLength(2,2));
|
|
AssertEquals('Len //', 0, PasHighLighter.FoldLineLength(6,0));
|
|
|
|
// Pg Pc 3 e e $e //
|
|
CheckFoldOpenCounts('', [1, 1, 3, 0, 0, 0, 0]);
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaFold],
|
|
[1, 1, 3, 0, 0, 0, 1]);
|
|
|
|
|
|
SetLines(TestTextFoldInfo4(2));
|
|
EnableFolds([cfbtBeginEnd..cfbtNone], [cfbtSlashComment]);
|
|
PushBaseName('Text 4 (mixed group) 1');
|
|
|
|
AssertEquals('Len Prog', 6, PasHighLighter.FoldLineLength(0,0));
|
|
AssertEquals('Len Proc', 3, PasHighLighter.FoldLineLength(1,0));
|
|
AssertEquals('Len IF', 3, PasHighLighter.FoldLineLength(2,2));
|
|
AssertEquals('Len beg 1', 2, PasHighLighter.FoldLineLength(2,0));
|
|
AssertEquals('Len beg 2', 1, PasHighLighter.FoldLineLength(2,1));
|
|
AssertEquals('Len //', 0, PasHighLighter.FoldLineLength(6,0));
|
|
|
|
// Pg Pc 3 e e $e //
|
|
CheckFoldOpenCounts('', [1, 1, 3, 0, 0, 0, 0]);
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaFold],
|
|
[1, 1, 3, 0, 0, 0, 1]);
|
|
{%endregion}
|
|
|
|
{%region}
|
|
SetLines(TestTextFoldInfo5);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone], [cfbtSlashComment]);
|
|
PushBaseName('Text 5 (class in generic type)');
|
|
|
|
AssertEquals('Len Unit', 11, PasHighLighter.FoldLineLength( 0,0));
|
|
AssertEquals('Len Intf', 7, PasHighLighter.FoldLineLength( 1,0));
|
|
AssertEquals('Len type', 6, PasHighLighter.FoldLineLength( 2,0));
|
|
AssertEquals('Len class', 2, PasHighLighter.FoldLineLength( 3,0));
|
|
AssertEquals('Len record', 2, PasHighLighter.FoldLineLength( 6,0));
|
|
AssertEquals('Len Impl', 1, PasHighLighter.FoldLineLength( 9,0));
|
|
AssertEquals('Len //', 0, PasHighLighter.FoldLineLength(10,0));
|
|
|
|
// un in ty cl pr en re pr en im // en
|
|
CheckFoldOpenCounts('', [1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0]);
|
|
CheckFoldInfoCounts('', [sfaOpenFold, sfaFold],
|
|
[1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0]);
|
|
CheckFoldInfoCounts('', [sfaCloseFold, sfaFold, sfaLastLineClose],
|
|
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
|
|
CheckFoldInfoCounts('', [sfaLastLineClose],
|
|
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
|
|
{%endregion}
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestExtendedKeywordsAndStrings;
|
|
begin
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'Program A;',
|
|
'var',
|
|
' Foo1: String;',
|
|
' Foo2: AnsiString;',
|
|
' Foo3: WideString;',
|
|
' Foo4: Shortstring;',
|
|
' Foo5: Integer;',
|
|
'',
|
|
'Procedure b;',
|
|
'begin',
|
|
' while Foo1 <> '''' do',
|
|
' continue;',
|
|
' exit;',
|
|
'end',
|
|
'',
|
|
'begin',
|
|
'end',
|
|
''
|
|
]);
|
|
|
|
PushBaseName('spsmDefault');
|
|
PasHighLighter.StringKeywordMode := spsmDefault;
|
|
CheckTokensForLine('String', 2, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkKey, tkSymbol ]);
|
|
CheckTokensForLine('ansi', 3, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkKey, tkSymbol ]);
|
|
CheckTokensForLine('wide', 4, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkKey, tkSymbol ]);
|
|
CheckTokensForLine('short', 5, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkKey, tkSymbol ]);
|
|
CheckTokensForLine('int', 6, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]); // selftest
|
|
|
|
PopPushBaseName('spsmStringOnly');
|
|
PasHighLighter.StringKeywordMode := spsmStringOnly;
|
|
CheckTokensForLine('String', 2, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkKey, tkSymbol ]);
|
|
CheckTokensForLine('ansi', 3, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('wide', 4, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('short', 5, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('int', 6, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]); // selftest
|
|
|
|
PopPushBaseName('spsmNone');
|
|
PasHighLighter.StringKeywordMode := spsmNone;
|
|
CheckTokensForLine('String', 2, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('ansi', 3, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('wide', 4, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('short', 5, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('int', 6, [tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]); // selftest
|
|
|
|
|
|
PopPushBaseName('False');
|
|
PasHighLighter.ExtendedKeywordsMode := False;
|
|
CheckTokensForLine('continue', 11, [tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('exit', 12, [tkSpace, tkIdentifier, tkSymbol ]);
|
|
|
|
PopPushBaseName('True');
|
|
PasHighLighter.ExtendedKeywordsMode := True;
|
|
CheckTokensForLine('continue', 11, [tkSpace, tkKey, tkSymbol ]);
|
|
CheckTokensForLine('exit', 12, [tkSpace, tkKey, tkSymbol ]);
|
|
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestRaiseAt;
|
|
begin
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'program A;',
|
|
'begin',
|
|
' raise foo at 1;', // 2
|
|
' raise at AT at;',
|
|
' raise at + at AT at.at;', // 4
|
|
' raise at.at at AT + at;',
|
|
' raise at(at, at) AT at + at;', // 6
|
|
' raise at(at, at).at AT at + at;',
|
|
' raise at(at, at) + at AT at + at;',
|
|
'',
|
|
'end.'
|
|
]);
|
|
|
|
CheckTokensForLine('foo at 1', 2,
|
|
[ tkSpace, tkKey, tkSpace, tkIdentifier, tkSpace,
|
|
tkKey{at}, tkSpace, tkNumber, TK_Semi ]);
|
|
CheckTokensForLine('at AT at', 3,
|
|
[ tkSpace, tkKey, tkSpace, tkIdentifier, tkSpace,
|
|
tkKey{at}, tkSpace, tkIdentifier, TK_Semi ]);
|
|
CheckTokensForLine('at + at AT at.at', 4,
|
|
[ tkSpace, tkKey, tkSpace, tkIdentifier, tkSpace, tkSymbol, tkSpace, tkIdentifier, tkSpace,
|
|
tkKey{at}, tkSpace, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi ]);
|
|
CheckTokensForLine('at.at AT at + at', 5,
|
|
[ tkSpace, tkKey, tkSpace, tkIdentifier, TK_Dot, tkIdentifier, tkSpace,
|
|
tkKey{at}, tkSpace, tkIdentifier, tkSpace, tkSymbol, tkSpace, tkIdentifier, TK_Semi ]);
|
|
CheckTokensForLine('at(at, at) AT at + at', 6,
|
|
[ tkSpace, tkKey, tkSpace, tkIdentifier,TK_Bracket, tkIdentifier, TK_Comma, tkSpace, tkIdentifier, TK_Bracket, tkSpace,
|
|
tkKey{at}, tkSpace, tkIdentifier, tkSpace, tkSymbol, tkSpace, tkIdentifier, TK_Semi ]);
|
|
CheckTokensForLine('at(at, at).at AT at + at', 7,
|
|
[ tkSpace, tkKey, tkSpace, tkIdentifier,TK_Bracket, tkIdentifier, TK_Comma, tkSpace, tkIdentifier, TK_Bracket, TK_Dot, tkIdentifier, tkSpace,
|
|
tkKey{at}, tkSpace, tkIdentifier, tkSpace, tkSymbol, tkSpace, tkIdentifier, TK_Semi ]);
|
|
CheckTokensForLine('at(at, at) + at AT at + at', 8,
|
|
[ tkSpace, tkKey, tkSpace, tkIdentifier,TK_Bracket, tkIdentifier, TK_Comma, tkSpace, tkIdentifier, TK_Bracket, tkSpace, tkSymbol, tkSpace, tkIdentifier, tkSpace,
|
|
tkKey{at}, tkSpace, tkIdentifier, tkSpace, tkSymbol, tkSpace, tkIdentifier, TK_Semi ]);
|
|
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForProcModifiers;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to $10-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
if (i and $08) = 0 then AFolds := AFolds - [cfbtClassSection];
|
|
|
|
{%region message modifier for procedure}
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type TFoo=class',
|
|
'message: message;',
|
|
'Procedure message(message: message); message 100;',
|
|
'property message: message read message;',
|
|
'end;',
|
|
'var',
|
|
' message: message;',
|
|
'Procedure message(message: message);'
|
|
]);
|
|
CheckTokensForLine('class field', 2,
|
|
[ tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('class, proc message', 3,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, // "Procedure", " ", "message", "("
|
|
tkIdentifier, tkSymbol, tkSpace, tkIdentifier, // "message",, ":", " ", "message"
|
|
tkSymbol, tkSymbol, tkSpace, // ")", ";", " "
|
|
tkModifier, // "message" as key
|
|
tkSpace, tkNumber, tkSymbol
|
|
]);
|
|
CheckTokensForLine('property', 4,
|
|
[ tkKey, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSpace, tkKey, tkSpace, tkIdentifier ]);
|
|
|
|
CheckTokensForLine('var', 7,
|
|
[ tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('procedure', 8,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, // "Procedure", " ", "message", "("
|
|
tkIdentifier, tkSymbol, tkSpace, tkIdentifier, // "message",, ":", " ", "message"
|
|
tkSymbol, tkSymbol // ")", ";"
|
|
]);
|
|
|
|
{%endregion}
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForProcModifiers2;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i, j: Integer;
|
|
n: String;
|
|
begin
|
|
ReCreateEdit;
|
|
for i := 0 to $10-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
if (i and $08) = 0 then AFolds := AFolds - [cfbtProcedure];
|
|
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface', // 0
|
|
'type',
|
|
'cdecl=function(cdecl:cdecl):cdecl;cdecl;',
|
|
'type',
|
|
'Stdcall=class(cdecl)',
|
|
'function Stdcall(Stdcall:Stdcall):Stdcall;Stdcall;deprecated;', // 5
|
|
'property cdecl:cdecl read cdecl;',
|
|
'end;',
|
|
'',
|
|
'cdecl=record',
|
|
'function cdecl(cdecl:cdecl):cdecl;cdecl;deprecated;', // 10
|
|
'end;',
|
|
'',
|
|
'var',
|
|
'Stdcall:function(cdecl:cdecl):cdecl;cdecl;',
|
|
'var', // 15
|
|
'cdecl:cdecl;',
|
|
'',
|
|
'function Stdcall(cdecl:cdecl):cdecl;cdecl;',
|
|
'var',
|
|
'cdecl:cdecl deprecated;', // 20
|
|
'function Stdcall(cdecl:cdecl):cdecl;cdecl;deprecated;',
|
|
'',
|
|
// in []
|
|
'function Stdcall:cdecl;[cdecl];', // 23
|
|
'procedure Stdcall; [cdecl];',
|
|
'',
|
|
|
|
// no semicolon
|
|
'function Stdcall:cdecl cdecl;', // 26
|
|
'function Stdcall():cdecl cdecl;',
|
|
'procedure Stdcall cdecl;',
|
|
'procedure Stdcall() cdecl;',
|
|
'function Stdcall:cdecl [cdecl];', // not a modifire / not currently
|
|
'',
|
|
// anonym
|
|
'implementation', // 32
|
|
'procedure foo cdecl;',
|
|
'begin',
|
|
' procedure() cdecl begin end();',
|
|
' procedure() [cdecl] begin end();',
|
|
'end',
|
|
'',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('type cdecl', 2,
|
|
[ tkIdentifier, TK_Equal, tkKey, // cdecl=function
|
|
TK_Bracket, tkIdentifier, TK_Comma, tkIdentifier, TK_Bracket, // (cdecl:cdecl)
|
|
TK_Colon, tkIdentifier, TK_Semi, tkModifier, TK_Semi // :cdecl;cdecl;
|
|
]);
|
|
|
|
CheckTokensForLine('StdCall=class', 4,
|
|
[ tkIdentifier, TK_Equal, tkKey, // Stdcall=class
|
|
TK_Bracket, tkIdentifier, TK_Bracket // (cdecl)
|
|
]);
|
|
|
|
CheckTokensForLine('function/method cdecl', 5,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function cdecl
|
|
TK_Bracket, tkIdentifier, TK_Comma, tkIdentifier, TK_Bracket, // (cdecl:cdecl)
|
|
TK_Colon, tkIdentifier, TK_Semi, tkModifier, TK_Semi, // :cdecl;cdecl;
|
|
tkModifier, TK_Semi //deprecated;
|
|
]);
|
|
|
|
CheckTokensForLine('property', 6,
|
|
[ tkKey, tkSpace, tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkKey, tkSpace, tkIdentifier, TK_Semi ]);
|
|
|
|
CheckTokensForLine('StdCall=record', 9,
|
|
[ tkIdentifier, TK_Equal, tkKey // Stdcall=record
|
|
]);
|
|
|
|
CheckTokensForLine('funciton in record', 10,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function cdecl
|
|
TK_Bracket, tkIdentifier, TK_Comma, tkIdentifier, TK_Bracket, // (cdecl:cdecl)
|
|
TK_Colon, tkIdentifier, TK_Semi, tkModifier, TK_Semi, // :cdecl;cdecl;
|
|
tkModifier, TK_Semi //deprecated;
|
|
]);
|
|
|
|
CheckTokensForLine('var cdecl function', 14,
|
|
[ tkIdentifier, TK_Equal, tkKey, // Stdcall:function
|
|
TK_Bracket, tkIdentifier, TK_Comma, tkIdentifier, TK_Bracket, // (cdecl:cdecl)
|
|
TK_Colon, tkIdentifier, TK_Semi, tkModifier, TK_Semi // :cdecl;cdecl;
|
|
]);
|
|
|
|
CheckTokensForLine('var cdecl:cdecl', 16,
|
|
[ tkIdentifier, TK_Colon, tkIdentifier, TK_Semi //cdecl:cdecl;
|
|
]);
|
|
|
|
CheckTokensForLine('function', 18,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function StdCall
|
|
TK_Bracket, tkIdentifier, TK_Comma, tkIdentifier, TK_Bracket, // (cdecl:cdecl)
|
|
TK_Colon, tkIdentifier, TK_Semi, tkModifier, TK_Semi // :cdecl;cdecl;
|
|
]);
|
|
|
|
CheckTokensForLine('var cdecl deprecated:cdecl', 20,
|
|
[ tkIdentifier, TK_Colon, tkIdentifier, //cdecl:cdecl
|
|
tkSpace, tkModifier, TK_Semi //deprecated;
|
|
]);
|
|
|
|
CheckTokensForLine('function deprecated', 21,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function StdCall
|
|
TK_Bracket, tkIdentifier, TK_Comma, tkIdentifier, TK_Bracket, // (cdecl:cdecl)
|
|
TK_Colon, tkIdentifier,TK_Semi, // :cdecl;
|
|
tkModifier, TK_Semi, // cdecl;
|
|
tkModifier, TK_Semi //deprecated;
|
|
]);
|
|
|
|
|
|
CheckTokensForLine('function Stdcall:cdecl;[cdecl];', 23,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Colon, tkIdentifier, TK_Semi,
|
|
TK_Bracket, tkModifier, TK_Bracket, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure Stdcall; [cdecl];', 24,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Colon, tkSpace,
|
|
TK_Bracket, tkModifier, TK_Bracket, TK_Semi
|
|
]);
|
|
|
|
CheckTokensForLine('function Stdcall:cdecl cdecl;', 26,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Colon, tkIdentifier, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('function Stdcall():cdecl cdecl;', 27,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Bracket, TK_Bracket, TK_Colon,
|
|
tkIdentifier, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure Stdcall cdecl;', 28,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure Stdcall() cdecl;', 29,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Bracket, TK_Bracket, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('function Stdcall:cdecl [cdecl];', 30, // not a modifire / not currently
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Colon, tkIdentifier, tkSpace,
|
|
TK_Bracket, tkIdentifier {maybe modifier in future fpc version?}, TK_Bracket, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure foo cdecl;', 33,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
|
|
CheckTokensForLine(' procedure() cdecl begin end();', 35,
|
|
[ tkSpace, tkKey, TK_Bracket, TK_Bracket, tkSpace,
|
|
tkModifier,
|
|
tkSpace, tkKey, tkSpace, tkKey,
|
|
TK_Bracket, TK_Bracket, TK_Semi
|
|
]);
|
|
CheckTokensForLine(' procedure() [cdecl] begin end();', 36,
|
|
[ tkSpace, tkKey, TK_Bracket, TK_Bracket, tkSpace,
|
|
TK_Bracket, tkModifier, TK_Bracket,
|
|
tkSpace, tkKey, tkSpace, tkKey,
|
|
TK_Bracket, TK_Bracket, TK_Semi
|
|
]);
|
|
|
|
|
|
for j := 0 to 6 do begin
|
|
case j of
|
|
0: n := 'overload';
|
|
1: n := 'assembler';
|
|
2: n := 'alias';
|
|
3: n := 'inline';
|
|
4: n := 'weakexternal';
|
|
5: n := 'compilerproc';
|
|
6: n := 'forward';
|
|
end;
|
|
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'var',
|
|
n+':function:'+n+';'+n+':'+n+';',
|
|
'type',
|
|
n+'=function:'+n+';'+n+':'+n+';',
|
|
'function '+n+':'+n+';'+n+';',
|
|
'type',
|
|
n+'=class('+n+') public',
|
|
n+':function:'+n+';'+n+':'+n+';',
|
|
'function '+n+':'+n+';'+n+';',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine(n+':function:'+n+';'+n+':'+n+';',2,
|
|
[ tkIdentifier, TK_Colon, tkKey, TK_Colon, tkIdentifier, TK_Semi,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+'=function:'+n+';'+n+':'+n+';',4,
|
|
[ tkIdentifier, TK_Colon, tkKey, TK_Colon, tkIdentifier, TK_Semi,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('function '+n+':'+n+';'+n+';',5,
|
|
[ tkKey, tkSpace, tkIdentifier+FAttrProcName, TK_Colon, tkIdentifier, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
|
|
CheckTokensForLine(n+':function:'+n+';'+n+':'+n+';',8,
|
|
[ tkIdentifier, TK_Colon, tkKey, TK_Colon, tkIdentifier, TK_Semi,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi
|
|
]);
|
|
if j = 6 then
|
|
continue;
|
|
CheckTokensForLine('function '+n+':'+n+';'+n+';',9,
|
|
[ tkKey, tkSpace, tkIdentifier+FAttrProcName, TK_Colon, tkIdentifier, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
|
|
end;
|
|
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForProcModifiersName;
|
|
var
|
|
p: TSynHighlighterAttributesModifier;
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
ReCreateEdit;
|
|
p := FAttrProcName;
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'procedure name; external ''name'' name ''name'';',
|
|
'procedure name; public name ''name'';',
|
|
' begin end;',
|
|
'function name: name; external ''name'' name ''name'';', // 4
|
|
'function name: name; public name ''name'';',
|
|
' begin end;',
|
|
'',
|
|
'type TFoo = class ', // 8
|
|
'procedure name; public name: name;', // just a public field
|
|
'function name: name; public name: name;', // just a public field
|
|
'end;',
|
|
'', // 12
|
|
'procedure name; external name name;', // external keyword_NAME const_NAME
|
|
'procedure name; external foo name name;', // external foo keyword_NAME const_NAME
|
|
''
|
|
]);
|
|
|
|
for i := 0 to $3F do begin
|
|
AFolds := [];
|
|
if (i and $20) = 0 then AFolds := [cfbtBeginEnd..cfbtNone] - [cfbtUnitSection, cfbtProcedure, cfbtVarBlock, cfbtClass, cfbtClassSection];
|
|
if (i and $01) = 0 then AFolds := AFolds + [cfbtUnitSection];
|
|
if (i and $02) = 0 then AFolds := AFolds + [cfbtProcedure];
|
|
if (i and $04) = 0 then AFolds := AFolds + [cfbtVarBlock];
|
|
if (i and $08) = 0 then AFolds := AFolds + [cfbtClass];
|
|
if (i and $10) = 0 then AFolds := AFolds + [cfbtClassSection];
|
|
|
|
EnableFolds(AFolds);
|
|
|
|
CheckTokensForLine('procedure name; external ''name'' name ''name'';', 1,
|
|
[tkKey, tkSpace, tkIdentifier+p, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkString, tkSpace, tkModifier, tkSpace, tkString, TK_Semi]);
|
|
CheckTokensForLine('procedure name; public name ''name'';', 2,
|
|
[tkKey, tkSpace, tkIdentifier+p, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi]);
|
|
|
|
CheckTokensForLine('function name: name; external ''name'' name ''name'';', 4,
|
|
[tkKey, tkSpace, tkIdentifier+p, TK_Colon, tkSpace, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkString, tkSpace, tkModifier, tkSpace, tkString, TK_Semi]);
|
|
CheckTokensForLine('function name: name; public name ''name'';', 5,
|
|
[tkKey, tkSpace, tkIdentifier+p, TK_Colon, tkSpace, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi]);
|
|
|
|
CheckTokensForLine('CLASS: procedure name; public name: name;', 9,
|
|
[tkKey, tkSpace, tkIdentifier+p, TK_Semi, tkSpace,
|
|
tkKey, tkSpace, tkIdentifier, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('CLASS: function name: name; public name: name;', 10,
|
|
[tkKey, tkSpace, tkIdentifier+p, TK_Colon, tkSpace, tkIdentifier, TK_Semi, tkSpace,
|
|
tkKey, tkSpace, tkIdentifier, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
CheckTokensForLine('procedure name; external name name;', 13,
|
|
[tkKey, tkSpace, tkIdentifier+p, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
CheckTokensForLine('procedure name; external foo name name;', 14,
|
|
[tkKey, tkSpace, tkIdentifier+p, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkIdentifier, tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForVarModifiers;
|
|
var
|
|
n: String;
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i, j: Integer;
|
|
begin
|
|
ReCreateEdit;
|
|
for i := 0 to 7 do begin
|
|
case i of
|
|
0: n := 'name';
|
|
1: n := 'public';
|
|
2: n := 'external';
|
|
3: n := 'export';
|
|
4: n := 'cvar';
|
|
5: n := 'deprecated';
|
|
6: n := 'default';
|
|
7: n := 'absolute';
|
|
end;
|
|
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'',
|
|
'var ',
|
|
// Line 3:
|
|
n+':'+n+'; public;',
|
|
n+':'+n+'; public name ''name'';',
|
|
n+':'+n+'; external;',
|
|
n+':'+n+'; external ''name'';',
|
|
n+':'+n+'; external name ''name'';',
|
|
n+':'+n+'; external ''name'' name ''name'';',
|
|
n+':'+n+'; export;',
|
|
n+':'+n+'; export name ''name'';',
|
|
'',
|
|
'',
|
|
// Line 13:
|
|
n+':'+n+';cvar; public;',
|
|
n+':'+n+';cvar; public name ''name'';',
|
|
n+':'+n+';cvar; external;',
|
|
n+':'+n+';cvar; external ''name'';',
|
|
'',//n+':'+n+';cvar; external name ''name'';',
|
|
'',//n+':'+n+';cvar; external ''name'' name ''name'';',
|
|
n+':'+n+';cvar; export;',
|
|
n+':'+n+';cvar; export name ''name'';',
|
|
n+':'+n+';cvar; cvar: cvar; name: name; var', // just another variable
|
|
'',
|
|
// Line 23:
|
|
n+':'+n+'=1; public;',
|
|
n+':'+n+'=1; public name ''name'';',
|
|
'',//n+':'+n+'=1; external;',
|
|
'',//n+':'+n+'=1; external ''name'';',
|
|
'',//n+':'+n+'=1; external name ''name'';',
|
|
'',//n+':'+n+'=1; external ''name'' name ''name'';',
|
|
n+':'+n+'=1; export;',
|
|
n+':'+n+'=1; export name ''name'';',
|
|
'',
|
|
'',
|
|
// Line 33:
|
|
n+':'+n+' deprecated; public;',
|
|
n+':'+n+' deprecated; public name ''name'';',
|
|
n+':'+n+' deprecated; external;',
|
|
n+':'+n+' deprecated; external ''name'';',
|
|
n+':'+n+' deprecated; external name ''name'';',
|
|
n+':'+n+' deprecated; external ''name'' name ''name'';',
|
|
n+':'+n+' deprecated; export;',
|
|
n+':'+n+' deprecated; export name ''name'';',
|
|
'',
|
|
'',
|
|
// Line 43:
|
|
n+':'+n+' absolute '+n+';',
|
|
'',
|
|
'',
|
|
'',
|
|
'type',
|
|
// Line 48:
|
|
n+'='+n+'; '+n+'='+n+';', // just another type
|
|
'const',
|
|
// Line 50:
|
|
n+'='+n+'; '+n+'='+n+';', // just another const
|
|
n+':'+n+'='+n+'; cvar;', // key CVAR
|
|
n+':'+n+'='+n+'; cvar; public;', // key CVAR
|
|
n+':'+n+'='+n+'; public;', // key public
|
|
n+':'+n+'='+n+'; public name ''name'';', // key public name
|
|
'',
|
|
'',
|
|
'',
|
|
'',
|
|
// NOT for "public"
|
|
'type TFoo = class ',
|
|
// Line 60:
|
|
n+':'+n+'; '+n+':'+n+'; public private', // just another field
|
|
n+':'+n+'; public '+n+':'+n+'; public private', // just another public field
|
|
'var '+n+':'+n+'; public '+n+':'+n+'; public private', // just another public field
|
|
'type '+n+':'+n+'; '+n+':'+n+'; public private', // just another type
|
|
'const '+n+':'+n+'='+n+'; '+n+':'+n+'='+n+'; public private', // just another const
|
|
'',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
for j := 0 to $1F do begin
|
|
AFolds := [];
|
|
if (j and $10) = 0 then AFolds := [cfbtBeginEnd..cfbtNone] - [cfbtUnitSection, cfbtVarBlock, cfbtClass, cfbtClassSection];
|
|
if (j and $01) = 0 then AFolds := AFolds + [cfbtUnitSection];
|
|
if (j and $02) = 0 then AFolds := AFolds + [cfbtVarBlock];
|
|
if (j and $04) = 0 then AFolds := AFolds + [cfbtClass];
|
|
if (j and $08) = 0 then AFolds := AFolds + [cfbtClassSection];
|
|
EnableFolds(AFolds);
|
|
|
|
CheckTokensForLine(n+':'+n+'; public;', 3,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'; public name ''name'';', 4,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'; external;', 5,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'; external ''name'';', 6,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'; external name ''name'';', 7,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'; external ''name'' name ''name'';', 8,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkString, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'; export;', 9,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'; export name ''name'';', 10,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
|
|
CheckTokensForLine(n+':'+n+';cvar; public;', 13,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkModifier {cvar}, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+';cvar; public name ''name'';', 14,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkModifier {cvar}, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+';cvar; external;', 15,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkModifier {cvar}, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+';cvar; external ''name'';', 16,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkModifier {cvar}, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
// CheckTokensForLine(n+':'+n+';cvar; external name ''name'';', 17,
|
|
// tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
// [tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace, tkModifier {cvar}, TK_Semi, tkSpace,
|
|
// ]);
|
|
// CheckTokensForLine(n+':'+n+';cvar; external ''name'' name ''name'';', 18,
|
|
// [tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace, tkModifier {cvar}, TK_Semi, tkSpace,
|
|
// tkModifier, tkSpace, tkString, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
// ]);
|
|
CheckTokensForLine(n+':'+n+';cvar; export;', 19,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkModifier {cvar}, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+';cvar; export name ''name'';', 20,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkModifier {cvar}, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
// just another var:
|
|
CheckTokensForLine(n+':'+n+';cvar; cvar: cvar; name: name; var', 21,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkModifier {cvar}, TK_Semi, tkSpace,
|
|
tkIdentifier, TK_Colon, tkSpace, tkIdentifier, TK_Semi, tkSpace,
|
|
tkIdentifier, TK_Colon, tkSpace, tkIdentifier, TK_Semi,
|
|
tkSpace, tkkey
|
|
]);
|
|
|
|
CheckTokensForLine(n+':'+n+'=1; public;', 23,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkNumber, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'=1; public name ''name'';', 24,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkNumber, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
// CheckTokensForLine(n+':'+n+'=1; external;', 25,
|
|
// [tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkNumber, TK_Semi, tkSpace,
|
|
// tkModifier, TK_Semi
|
|
// ]);
|
|
// CheckTokensForLine(n+':'+n+'=1; external ''name'';', 26,
|
|
// [tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkNumber, TK_Semi, tkSpace,
|
|
// tkModifier, tkSpace, tkString, TK_Semi
|
|
// ]);
|
|
// CheckTokensForLine(n+':'+n+'=1; external name ''name'';', 27,
|
|
// [tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkNumber, TK_Semi, tkSpace,
|
|
// tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
// ]);
|
|
// CheckTokensForLine(n+':'+n+'=1; external ''name'' name ''name'';', 28,
|
|
// [tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkNumber, TK_Semi, tkSpace,
|
|
// tkModifier, tkSpace, tkString, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
// ]);
|
|
CheckTokensForLine(n+':'+n+'=1; export;', 29,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkNumber, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'=1; export name ''name'';', 30,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkNumber, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
|
|
CheckTokensForLine(n+':'+n+' deprecated; public;', 33,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier{depr}, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+' deprecated; public name ''name'';', 34,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier{depr}, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+' deprecated; external;', 35,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier{depr}, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+' deprecated; external ''name'';', 36,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier{depr}, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+' deprecated; external name ''name'';', 37,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier{depr}, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+' deprecated; external ''name'' name ''name'';', 38,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier{depr}, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkString, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+' deprecated; export;', 39,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier{depr}, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+' deprecated; export name ''name'';', 40,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier{depr}, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
|
|
CheckTokensForLine(n+':'+n+' absolute '+n+';', 43,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier{absolute}, tkSpace, tkIdentifier, TK_Semi ]);
|
|
|
|
//TYPE / just another type
|
|
CheckTokensForLine(n+'='+n+'; '+n+'='+n+';', 48,
|
|
[tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace,
|
|
tkIdentifier, TK_Equal, tkIdentifier, TK_Semi]);
|
|
|
|
// const
|
|
CheckTokensForLine(n+'='+n+'; '+n+'='+n+';', 50, // just another const
|
|
[tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace,
|
|
tkIdentifier, TK_Equal, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine(n+':'+n+'='+n+'; cvar;', 51, // key CVAR
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
|
|
if copy(n,1,6) = 'public' then
|
|
continue;
|
|
// NOT for "public"
|
|
CheckTokensForLine(n+':'+n+'='+n+'; cvar; public;', 52, // key CVAR
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'='+n+'; public;', 53, // key public
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine(n+':'+n+'='+n+'; public name ''name'';', 54, // key public name
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
|
|
// NOT for "public"
|
|
CheckTokensForLine('#CLASS#'+ n+':'+n+'; '+n+':'+n+'; public private', 60,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace, tkKey {public}, tkSpace, tkKey {private}
|
|
]);
|
|
CheckTokensForLine('#CLASS#'+n+':'+n+'; public '+n+':'+n+'; public private', 61,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace, tkKey {public}, tkSpace,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace, tkKey {public}, tkSpace, tkKey {private}
|
|
]);
|
|
CheckTokensForLine('#CLASS#'+'var '+n+':'+n+'; public '+n+':'+n+'; public private', 62,
|
|
[tkKey{var}, tkSpace,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace, tkKey {public}, tkSpace,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace, tkKey {public}, tkSpace, tkKey {private}
|
|
]);
|
|
CheckTokensForLine('#CLASS#'+'type '+n+'='+n+'; '+n+'='+n+'; public private', 63,
|
|
[tkKey{type}, tkSpace,
|
|
tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace,
|
|
tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace, tkKey {public}, tkSpace, tkKey {private}]);
|
|
CheckTokensForLine('#CLASS#'+'const '+n+':'+n+'='+n+'; '+n+':'+n+'='+n+'; public private', 64, // just another const
|
|
[tkKey{const}, tkSpace,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkIdentifier, TK_Semi, tkSpace, tkKey {public}, tkSpace, tkKey {private}]);
|
|
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForVarModifiers2;
|
|
begin
|
|
ReCreateEdit;
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'var',
|
|
'name: name; external name name;', // external const_NAME keyword_NAME const_NAME
|
|
'name: name; external foo name name;', // external const_NAME keyword_NAME const_NAME
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('name: name; external name name;', 2,
|
|
[tkIdentifier, TK_Colon, tkSpace, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
CheckTokensForLine('name: name; external foo name name;', 3,
|
|
[tkIdentifier, TK_Colon, tkSpace, tkIdentifier, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkIdentifier, tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi]);
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForProperties;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to $10-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
if (i and $08) = 0 then AFolds := AFolds - [cfbtClassSection];
|
|
|
|
{%region property and index}
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type TFoo = class',
|
|
'property Index[Index: Integer]: Integer read GetIndex write SetIndex Index 3;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('property with index', 2,
|
|
[ tkKey, tkSpace, tkIdentifier, tkSymbol, // "property", " ", "Index", "["
|
|
tkIdentifier, tkSymbol, tkSpace, tkIdentifier, // "Index",, ":", " ", "Integer"
|
|
tkSymbol, tkSymbol, tkSpace, tkIdentifier, // "]", ":", " ", "Integer"
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // " ", 'read', " ", "GetIndex"
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // " ", 'write', " ", "SetIndex"
|
|
tkSpace, tkKey, tkSpace, tkNumber, // '" ", "INDEX" (key), " ", "3"
|
|
tkSymbol
|
|
]);
|
|
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type TFoo = class',
|
|
'property AnIndex[Index: Index]: Index read Index write Index Index 3;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('property with index 2', 2,
|
|
[ tkKey, tkSpace, tkIdentifier, tkSymbol, // "property", " ", "AnIndex", "["
|
|
tkIdentifier, tkSymbol, tkSpace, tkIdentifier, // "Index",, ":", " ", "Index"
|
|
tkSymbol, tkSymbol, tkSpace, tkIdentifier, // "]", ":", " ", "Index"
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // " ", 'read', " ", "Index"
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // " ", 'write', " ", "Index"
|
|
tkSpace, tkKey, tkSpace, tkNumber, // '" ", "INDEX" (key), " ", "3"
|
|
tkSymbol
|
|
]);
|
|
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'Index = Integer;',
|
|
'Foo = Index;',
|
|
'',
|
|
'var',
|
|
'Foo, Index: Index;',
|
|
'Index: Index;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('index outside property', 2,
|
|
[tkIdentifier, tkSpace, tkSymbol, tkSpace, tkIdentifier, tkSymbol]);
|
|
CheckTokensForLine('index outside property', 3,
|
|
[tkIdentifier, tkSpace, tkSymbol, tkSpace, tkIdentifier, tkSymbol]);
|
|
CheckTokensForLine('index outside property', 6,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol]);
|
|
CheckTokensForLine('index outside property', 7,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol]);
|
|
|
|
{%endregion}
|
|
|
|
{%region property and read/write}
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type TFoo = class',
|
|
'property read[read: read]: read read read write read;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('property "read"', 2,
|
|
[ tkKey, tkSpace, tkIdentifier, tkSymbol, // "property", " ", "read", "["
|
|
tkIdentifier, tkSymbol, tkSpace, tkIdentifier, // "read",, ":", " ", "read"
|
|
tkSymbol, tkSymbol, tkSpace, tkIdentifier, // "]", ":", " ", "read"
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // " ", 'READ', " ", "read"
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // " ", 'write', " ", "read"
|
|
tkSymbol
|
|
]);
|
|
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type TFoo = class',
|
|
'property write[write: write]: write read write write write;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('property "write"', 2,
|
|
[ tkKey, tkSpace, tkIdentifier, tkSymbol, // "property", " ", "write", "["
|
|
tkIdentifier, tkSymbol, tkSpace, tkIdentifier, // "write",, ":", " ", "write"
|
|
tkSymbol, tkSymbol, tkSpace, tkIdentifier, // "]", ":", " ", "write"
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // " ", 'read', " ", "write"
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // " ", 'write', " ", "write"
|
|
tkSymbol
|
|
]);
|
|
{%endregion}
|
|
|
|
{%region property and default}
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type TFoo = class',
|
|
'default,default:default;',
|
|
'private type',
|
|
'default=integer;',
|
|
'private',
|
|
'a: default;',
|
|
'default:default.default;',
|
|
{8} 'function default(default:default):default;',
|
|
{9} 'function default(default:default.default):default.default;',
|
|
{10} 'property default[default:default]:default read default write default; default;',
|
|
{11} 'property default:default read default default default;',
|
|
{12} 'property default:default index default read default default default-default+default;',
|
|
// property could read a field inside an embedded record
|
|
{13} 'property default:default.default index {C} default.default read {C} default.default {C} default default.default * default.default;',
|
|
{14} 'property default: default index not default.default read default default -default.default;',
|
|
{15} 'property default: default.default index specialize default<default, default>.default read default default default.default;',
|
|
{16} 'property default: specialize default<default, default> index specialize default<default, default>.default read default default specialize default<default, default>.default;',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('FIELD: default,default:default;', 2,
|
|
[ tkIdentifier, TK_Comma, tkIdentifier, // default , default
|
|
TK_Colon, tkIdentifier, TK_Semi // : default;
|
|
]);
|
|
|
|
CheckTokensForLine('TYPE: default=integer;', 4,
|
|
[ tkIdentifier, TK_Equal, tkIdentifier, TK_Semi // default = integer ;
|
|
]);
|
|
|
|
CheckTokensForLine('FIELD: default:default.default;', 7,
|
|
[ tkIdentifier, TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi // default : default . default ;
|
|
]);
|
|
|
|
CheckTokensForLine('function default(default:default):default;', 8,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function default
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket, // ( default : default )
|
|
TK_Colon, tkIdentifier, TK_Semi // : default;
|
|
]);
|
|
|
|
CheckTokensForLine('function default(default:default.default):default.default;', 9,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function default
|
|
TK_Bracket, tkIdentifier, TK_Colon, // ( default :
|
|
tkIdentifier, TK_Dot, tkIdentifier, TK_Bracket, // default . default )
|
|
TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi // : default . default;
|
|
]);
|
|
|
|
CheckTokensForLine('property default[default:default]:default read default write default; default;', 10,
|
|
[ tkKey, tkSpace, tkIdentifier, TK_Bracket, tkIdentifier, // property default[default
|
|
TK_Colon, tkIdentifier, TK_Bracket, TK_Colon, tkIdentifier, // :default]:default
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // read default
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // write default
|
|
TK_Semi, tkSpace, tkModifier, TK_Semi // ; default;
|
|
]);
|
|
|
|
CheckTokensForLine('property default:default read default default default;', 11,
|
|
[ tkKey, tkSpace, tkIdentifier, TK_Colon, tkIdentifier, //property default:default
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // read default
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, TK_Semi // default default;
|
|
]);
|
|
|
|
CheckTokensForLine('property default:default index default read default default default-default+default;', 12,
|
|
[ tkKey, tkSpace, tkIdentifier, TK_Colon, tkIdentifier, // property default:default
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // index default
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // read default
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // default default
|
|
tkSymbol, tkIdentifier, tkSymbol, tkIdentifier, TK_Semi // -default+default;
|
|
]);
|
|
|
|
CheckTokensForLine('property default:default.default index {C} default.default read {C} default.default {C} default default.default * default.default;', 13,
|
|
[ tkKey, tkSpace, tkIdentifier, TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, // property default:default.default
|
|
tkSpace, tkKey, tkSpace, tkComment, tkSpace, // index (C}
|
|
tkIdentifier, TK_Dot, tkIdentifier, tkSpace, // default.default
|
|
tkKey, tkSpace, tkComment, tkSpace, // read (C}
|
|
tkIdentifier, TK_Dot, tkIdentifier, tkSpace, // default.default
|
|
tkComment, tkSpace, // (C}
|
|
tkKey, tkSpace, tkIdentifier, TK_Dot, tkIdentifier, tkSpace, // default default.default
|
|
tkSymbol, tkSpace, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi // * default.default;
|
|
]);
|
|
|
|
CheckTokensForLine('property default: default index not default.default read default default -default.default;', 14,
|
|
[ tkKey, tkSpace, tkIdentifier, TK_Colon, tkSpace, tkIdentifier, tkSpace, // property default:default
|
|
tkKey, tkSpace, tkKey, tkSpace, tkIdentifier, TK_Dot, tkIdentifier, tkSpace, // index not default.default
|
|
tkKey, tkSpace, tkIdentifier, tkSpace, //read default
|
|
tkKey, tkSpace, tkSymbol, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi // default -default.default;
|
|
]);
|
|
|
|
CheckTokensForLine('property default: default.default index specialize default<default, default>.default read default default default.default;', 15,
|
|
[ tkKey, tkSpace, tkIdentifier, TK_Colon, tkSpace, tkIdentifier, TK_Dot, tkIdentifier, tkSpace, // property default: default.default
|
|
tkKey, tkSpace, tkKey, tkSpace, // index specialize
|
|
tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, //default<default, default>
|
|
tkSymbol, tkIdentifier, tkSpace, // .default
|
|
tkKey, tkSpace, tkIdentifier, tkSpace, // read default
|
|
tkKey, tkSpace, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi // default default.default;
|
|
]);
|
|
|
|
CheckTokensForLine('property default: specialize default<default, default> index specialize default<default, default>.default read default default specialize default<default, default>.default;', 16,
|
|
[ tkKey, tkSpace, tkIdentifier, TK_Colon, tkSpace, // property default:
|
|
tkKey, tkSpace, //specialize
|
|
tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, //default<default, default>
|
|
tkKey, tkSpace, tkKey, tkSpace, // index specialize
|
|
tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, // default<default, default>
|
|
tkSymbol, tkIdentifier, tkSpace, // .default
|
|
tkKey, tkSpace, tkIdentifier, tkSpace, // read default
|
|
tkKey, tkSpace, tkKey, tkSpace, // default specialize
|
|
tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, // default<default, default>
|
|
tkSymbol, tkIdentifier, TK_Semi // .default;
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
{%endregion}
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForProcedure;
|
|
var
|
|
AtP, AtI, AtK: TSynHighlighterAttributes;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
ReCreateEdit;
|
|
AtP := PasHighLighter.ProcedureHeaderName;
|
|
AtI := PasHighLighter.IdentifierAttri;
|
|
AtK := PasHighLighter.KeywordAttribute;
|
|
|
|
SetLines
|
|
([ 'Unit A;',
|
|
'interface',
|
|
'',
|
|
'type',
|
|
' IBar = interface',
|
|
{5} ' procedure p1;',
|
|
' procedure p2;',
|
|
' end;',
|
|
'',
|
|
'var',
|
|
{10} ' Foo: Procedure of object;', // no folding // do not end var block
|
|
' Foo: Procedure is nested;', // no folding // do not end var block
|
|
'',
|
|
'type',
|
|
' TBar= ',
|
|
{15} ' Function(): Boolean;', // no folding // do not end type block
|
|
'',
|
|
'Procedure a;', // no folding in interface
|
|
'',
|
|
'implementation',
|
|
{20} '',
|
|
'var',
|
|
' Foo2: Procedure of object;', // no folding // do not end var block
|
|
'',
|
|
'type',
|
|
{25} ' TBar2: ',
|
|
' Function(): Boolean;', // no folding // do not end type block
|
|
'',
|
|
'Procedure a;', // fold
|
|
'var',
|
|
' Foo3: Procedure of object;', // no folding // do not end var block
|
|
'',
|
|
'begin end;',
|
|
'',
|
|
'end.',
|
|
''
|
|
]);
|
|
|
|
for i := 0 to $20-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
if (i and $08) = 0 then AFolds := AFolds - [cfbtClassSection];
|
|
if (i and $10) = 0 then AFolds := AFolds - [cfbtProcedure];
|
|
EnableFolds(AFolds);
|
|
if i = $20-1 then begin
|
|
// fold depth / only for all folds enabled
|
|
CheckFoldOpenCounts('', [ 1, 1, 0,
|
|
1 {type}, 1, 0, 0, 0, 0,
|
|
1 {var}, 0, 0, 0, 1 {type}, 0, 0, 0,
|
|
0 {Proc}, 0,
|
|
1 {impl}, 0, 1 {var}, 0, 0, 1 {type}, 0, 0, 0,
|
|
1 {proc}, 1 {var}, 0, 0, 0, 0, 0
|
|
]);
|
|
AssertEquals('Len var 1 ', 3, PasHighLighter.FoldLineLength(9, 0));
|
|
AssertEquals('Len type 1 ', 3, PasHighLighter.FoldLineLength(13, 0));
|
|
AssertEquals('Len var 2 ', 2, PasHighLighter.FoldLineLength(21, 0));
|
|
AssertEquals('Len type 2 ', 3, PasHighLighter.FoldLineLength(24, 0));
|
|
AssertEquals('Len var 3 ', 2, PasHighLighter.FoldLineLength(29, 0));
|
|
end;
|
|
|
|
CheckTokensForLine('IBar.p1', 5, [ tkSpace, tkKey + AtK, tkSpace, tkIdentifier + AtP, tkSymbol ]);
|
|
CheckTokensForLine('IBar.p2', 6, [ tkSpace, tkKey + AtK, tkSpace, tkIdentifier + AtP, tkSymbol ]);
|
|
CheckTokensForLine('foo p of', 10, [ tkSpace, tkIdentifier, tkSymbol, tkSpace,
|
|
tkKey + AtK, tkSpace, tkKey + AtK {of}, tkSpace, tkKey, tkSymbol
|
|
]);
|
|
CheckTokensForLine('foo p is nested', 11, [ tkSpace, tkIdentifier, tkSymbol, tkSpace,
|
|
tkKey + AtK, tkSpace, tkKey + AtK {of}, tkSpace, tkKey, tkSymbol
|
|
]);
|
|
CheckTokensForLine('TBar', 15, [ tkSpace, tkKey + AtK, tkSymbol, tkSymbol, tkSymbol,
|
|
tkSpace, tkIdentifier + AtI, tkSymbol
|
|
]);
|
|
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForProcedureNameAttr;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'Unit A;',
|
|
{ 1} 'interface',
|
|
{ } '',
|
|
{ } 'TFoo=class',
|
|
{ 4} 'Procedure Bar;',
|
|
{ 5} 'function Bar:boolean;',
|
|
{ 6} 'function Bar(a:t.x):t.x;',
|
|
{ } 'end',
|
|
{ } '',
|
|
{ 9} 'Procedure Bar;',
|
|
{10} 'function Bar:boolean;',
|
|
{11} 'function Bar(a:t.x):t.x;',
|
|
{ } '',
|
|
{ } 'implementation',
|
|
{14} 'Procedure TFoo.Bar;',
|
|
{ } 'begin end;',
|
|
{16} 'function TFoo.Bar:boolean;',
|
|
{ } 'begin end;',
|
|
{18} 'function TFoo.Bar(a:t.x):t.x;',
|
|
{ } 'begin end;',
|
|
{20} 'Procedure Bar;',
|
|
{ } 'begin end;',
|
|
{22} 'function Bar:boolean;',
|
|
{ } 'begin end;',
|
|
{24} 'function Bar(a:t.x):t.x;',
|
|
{ } 'begin end;',
|
|
{ } '',
|
|
{ } 'var',
|
|
{28} 'p1:procedure deprecated;', // deprecated is not the name
|
|
{29} 'p2:procedure(a:int64) deprecated;',
|
|
{30} 'f1:function:int64 deprecated;',
|
|
{ } '',
|
|
{ } 'end.',
|
|
''
|
|
]);
|
|
|
|
for i := 0 to $20-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
if (i and $08) = 0 then AFolds := AFolds - [cfbtClassSection];
|
|
if (i and $10) = 0 then AFolds := AFolds - [cfbtProcedure];
|
|
EnableFolds(AFolds);
|
|
|
|
CheckTokensForLine('procedure Bar in class', 4,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Semi // Procedure Bar;
|
|
]);
|
|
|
|
CheckTokensForLine('function Bar:boolean in class', 5,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function Bar
|
|
TK_Colon, tkIdentifier, TK_Semi //: boolean;
|
|
]);
|
|
|
|
CheckTokensForLine('function Bar(a:t.x):boolean in class', 6,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function Bar
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Bracket, // (a:t.x)
|
|
TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi // :t.x;
|
|
]);
|
|
|
|
|
|
CheckTokensForLine('procedure Bar', 9,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Semi // Procedure Bar;
|
|
]);
|
|
|
|
CheckTokensForLine('function Bar:boolean', 10,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function Bar
|
|
TK_Colon, tkIdentifier, TK_Semi //: boolean;
|
|
]);
|
|
|
|
CheckTokensForLine('function Bar(a:t.x):boolean', 11,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function Bar
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Bracket, // (a:t.x)
|
|
TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi // :t.x;
|
|
]);
|
|
|
|
|
|
CheckTokensForLine('procedure TFoo.Bar', 14,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Dot + FAttrProcName, tkIdentifier + FAttrProcName, TK_Semi // Procedure TFoo.Bar;
|
|
]);
|
|
|
|
CheckTokensForLine('function TFoo.Bar:boolean', 16,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Dot + FAttrProcName, tkIdentifier + FAttrProcName, // function TFoo.Bar
|
|
TK_Colon, tkIdentifier, TK_Semi //: boolean;
|
|
]);
|
|
|
|
CheckTokensForLine('function TFoo.Bar(a:t.x):boolean', 18,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Dot + FAttrProcName, tkIdentifier + FAttrProcName, // function TFoo.Bar
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Bracket, // (a:t.x)
|
|
TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi // :t.x;
|
|
]);
|
|
|
|
|
|
|
|
CheckTokensForLine('procedure Bar', 20,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, TK_Semi // Procedure TFoo.Bar;
|
|
]);
|
|
|
|
CheckTokensForLine('function Bar:boolean', 22,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function TFoo.Bar
|
|
TK_Colon, tkIdentifier, TK_Semi //: boolean;
|
|
]);
|
|
|
|
CheckTokensForLine('function Bar(a:t.x):boolean', 24,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, // function TFoo.Bar
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Bracket, // (a:t.x)
|
|
TK_Colon, tkIdentifier, TK_Dot, tkIdentifier, TK_Semi // :t.x;
|
|
]);
|
|
|
|
|
|
|
|
CheckTokensForLine('var p1:procedure deprecated;', 28,
|
|
[ tkIdentifier, TK_Colon, tkKey, tkSpace, tkModifier, TK_Semi // p1:procedure deprecated;
|
|
]);
|
|
|
|
CheckTokensForLine('var p2:procedure(a:int64) deprecated;', 29,
|
|
[ tkIdentifier, TK_Colon, tkKey, // p2:procedure
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket, // (a:int64)
|
|
tkSpace, tkModifier, TK_Semi //deprecated;
|
|
]);
|
|
|
|
CheckTokensForLine('var f1:function:int64 deprecated;', 30,
|
|
[ tkIdentifier, TK_Colon, tkKey, // f1:function
|
|
TK_Colon, tkIdentifier, tkSpace, tkModifier, TK_Semi // :int64 deprecated;
|
|
]);
|
|
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForInterface;
|
|
var
|
|
AtP, AtI, AtK: TSynHighlighterAttributes;
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
ReCreateEdit;
|
|
AtK := PasHighLighter.KeywordAttribute;
|
|
|
|
SetLines
|
|
([ 'Unit A;',
|
|
'interface',
|
|
'',
|
|
'type',
|
|
' IBar = interface',
|
|
' procedure p1;',
|
|
' procedure p2;',
|
|
' end;',
|
|
'',
|
|
'var',
|
|
' IBar2: interface', // not allowed "anonymous class"
|
|
' procedure p1;',
|
|
' procedure p2;',
|
|
'',
|
|
'implementation',
|
|
''
|
|
]);
|
|
|
|
for i := 0 to $08-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
EnableFolds(AFolds);
|
|
if i = $08-1 then begin
|
|
CheckFoldOpenCounts('', [ 1, 1, 0,
|
|
1 {type}, 1, 0, 0, 0, 0,
|
|
1 {var}, 0, 0, 0, 0, 0
|
|
// implementation
|
|
]);
|
|
AssertEquals('Len type ', 5, PasHighLighter.FoldLineLength(3, 0));
|
|
AssertEquals('Len intf ', 3, PasHighLighter.FoldLineLength(4, 0));
|
|
AssertEquals('Len var ', 1, PasHighLighter.FoldLineLength(9, 0)); // ends at next procedure
|
|
end;
|
|
|
|
CheckTokensForLine('unit "interface"', 1,
|
|
[ tkKey + AtK ]);
|
|
CheckTokensForLine('type "interface"', 4,
|
|
[ tkSpace, tkIdentifier, tkSpace, tkSymbol, tkSpace, tkKey + AtK ]);
|
|
CheckTokensForLine('var "interface"', 10,
|
|
[ tkSpace, tkIdentifier, tkSymbol, tkSpace, tkKey + AtK ]); // not allowed, still a keyword
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForDeprecated;
|
|
procedure SubTest(s: String;
|
|
AEnbledTypes: TPascalCodeFoldBlockTypes;
|
|
AHideTypes: TPascalCodeFoldBlockTypes = [];
|
|
ANoFoldTypes: TPascalCodeFoldBlockTypes = []);
|
|
|
|
procedure SubTest2(struct: String);
|
|
begin
|
|
SetLines
|
|
([ 'Unit A; interface {$ModeSwitch nestedprocvars}',
|
|
'type',
|
|
'TFoo='+struct,
|
|
s+': '+s+' '+s+';', // nameDEPRECATED: typeDEPRECATED deprecated;
|
|
s+': array of '+s+' '+s+';', // nameDEPRECATED=array of typeDEPRECATED deprecated;
|
|
s+': array [1..2] of '+s+' '+s+';', // nameDEPRECATED=array of typeDEPRECATED deprecated;
|
|
s+': set of '+s+' '+s+';', // nameDEPRECATED=set of typeDEPRECATED deprecated;
|
|
s+': class of '+s+' '+s+';', // nameDEPRECATED=class of typeDEPRECATED deprecated;
|
|
s+': procedure '+s+';',
|
|
s+': procedure of object '+s+';',
|
|
s+': procedure(a:'+s+') '+s+';',
|
|
s+': procedure(a:'+s+') of object '+s+';',
|
|
s+': function:'+s+' '+s+';',
|
|
s+': function:'+s+' of object '+s+';',
|
|
s+': function(a:'+s+'):'+s+' '+s+';',
|
|
s+': function(a:'+s+'):'+s+' of object '+s+';',
|
|
s+': record end '+s+';', // nameDEPRECATED=packed record deprecated;
|
|
s+': packed record end '+s+';', // nameDEPRECATED=packed record deprecated;
|
|
'foo, '+s+', bar: Integer '+s+';',
|
|
'procedure '+s+'('+s+': '+s+'); '+s+';',
|
|
'end',
|
|
''
|
|
]);
|
|
//TODO: is nested
|
|
|
|
CheckTokensForLine('member in class', 3,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('array of', 4,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"of"}, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('array [1..2] of', 5,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkSymbol, tkNumber, tkSymbol, tkNumber, tkSymbol,
|
|
tkSpace, tkKey {"of"}, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('set of', 6,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"of"}, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('class of', 7,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"of"}, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure ', 8,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure of object ', 9,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"of"}, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure(a:s) ', 10,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey,
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket,
|
|
tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure(a:s) of object ', 11,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey,
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket,
|
|
tkSpace, tkKey {"of"}, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('function', 12,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, TK_Colon, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('function of object ', 13,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, TK_Colon, tkIdentifier, tkSpace, tkKey {"of"}, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('function(a:s)', 14,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey,
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket,
|
|
TK_Colon, tkIdentifier,
|
|
tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('function(a:s) of object ', 15,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey,
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket,
|
|
TK_Colon, tkIdentifier,
|
|
tkSpace, tkKey {"of"}, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('record end', 16,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"end"}, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('packed record end', 17,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey, tkSpace, tkKey {"end"}, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('multi member in class', 18,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace,tkIdentifier, tkSymbol, // ... ":"
|
|
tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
|
|
if copy(struct, 1,11) = 'record case' then // procedure not allowed in record-case
|
|
exit;
|
|
CheckTokensForLine('procedure in class', 19,
|
|
[tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol { ( }, tkIdentifier, tkSymbol { : },
|
|
tkSpace, tkIdentifier, tkSymbol { ) }, tkSymbol, tkSpace, tkModifier {the one and only}, tkSymbol
|
|
]);
|
|
|
|
if struct = 'byte;var' then
|
|
struct := 'byte;';
|
|
|
|
// NOT in record-case / no type allowed
|
|
SetLines
|
|
([ 'Unit A; interface {$modeswitch advancedrecords}{$ModeSwitch nestedprocvars}',
|
|
'type',
|
|
'TFoo='+struct+' type',
|
|
s+'= '+s+' '+s+';', // nameDEPRECATED= typeDEPRECATED deprecated;
|
|
s+'= array of '+s+' '+s+';', // nameDEPRECATED=array of typeDEPRECATED deprecated;
|
|
s+'= array [1..2] of '+s+' '+s+';', // nameDEPRECATED=array of typeDEPRECATED deprecated;
|
|
s+'= set of '+s+' '+s+';', // nameDEPRECATED=set of typeDEPRECATED deprecated;
|
|
s+'= class of '+s+' '+s+';', // nameDEPRECATED=class of typeDEPRECATED deprecated;
|
|
s+'= procedure '+s+';', // 8
|
|
'f= procedure; '+s+';', // 9
|
|
'f= procedure '+s+';'+s+';', // 10
|
|
'f= procedure of object '+s+';',
|
|
'f= procedure(a:'+s+') '+s+';',
|
|
'f= procedure(a:'+s+') of object '+s+';',
|
|
'f= function:'+s+' '+s+';',
|
|
'f= function:'+s+' of object '+s+';',
|
|
'f= function(a:'+s+'):'+s+' '+s+';',
|
|
'f= function(a:'+s+'):'+s+' of object '+s+';',
|
|
'f= record end '+s+';', // nameDEPRECATED=packed record deprecated;
|
|
s+'= packed record end '+s+';', // nameDEPRECATED=packed record deprecated;
|
|
'end',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('member in class', 3,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('array of', 4,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"of"}, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('array [1..2] of', 5,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkSymbol, tkNumber, tkSymbol, tkNumber, tkSymbol,
|
|
tkSpace, tkKey {"of"}, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('set of', 6,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"of"}, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('class of', 7,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"of"}, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
|
|
CheckTokensForLine('procedure ', 8,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure ', 9,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, TK_Semi, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure ', 10,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkModifier, TK_Semi, tkModifier, tkSymbol]);
|
|
|
|
CheckTokensForLine('procedure of object ', 11,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"of"}, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure(a:s) ', 12,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey,
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket,
|
|
tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure(a:s) of object ', 13,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey,
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket,
|
|
tkSpace, tkKey {"of"}, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('function', 14,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, TK_Colon, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('function of object ', 15,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, TK_Colon, tkIdentifier, tkSpace, tkKey {"of"}, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('function(a:s)', 16,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey,
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket,
|
|
TK_Colon, tkIdentifier,
|
|
tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('function(a:s) of object ', 17,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey,
|
|
TK_Bracket, tkIdentifier, TK_Colon, tkIdentifier, TK_Bracket,
|
|
TK_Colon, tkIdentifier,
|
|
tkSpace, tkKey {"of"}, tkSpace, tkKey, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('record end', 18,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey {"end"}, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('packed record end', 19,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkKey, tkSpace, tkKey {"end"}, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
|
|
if (struct = 'record') or (struct = 'byte;') then
|
|
exit;
|
|
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'TFoo='+struct,
|
|
s+': '+s+' '+s+';', // nameDEPRECATED: typeDEPRECATED deprecated;
|
|
'foo, '+s+', bar: Integer '+s+';',
|
|
'procedure '+s+'('+s+': '+s+'); '+s+';',
|
|
'private',
|
|
s+': '+s+' '+s+';', // nameDEPRECATED: typeDEPRECATED deprecated;
|
|
'foo, '+s+', bar: Integer '+s+';',
|
|
'property '+s+': '+s+' read '+s+'; '+s+';',
|
|
'procedure '+s+'('+s+': '+s+'); '+s+';',
|
|
'end',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('member in class', 3,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('multi member in class', 4,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace,tkIdentifier, tkSymbol, // ... ":"
|
|
tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure in class', 5,
|
|
[tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol { ( }, tkIdentifier, tkSymbol { : },
|
|
tkSpace, tkIdentifier, tkSymbol { ) }, tkSymbol, tkSpace, tkModifier {the one and only}, tkSymbol
|
|
]);
|
|
|
|
CheckTokensForLine('member in class-sect', 7,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('multi member in class-sect', 8,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace,tkIdentifier, tkSymbol, // ... ":"
|
|
tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('property in class-sect', 9,
|
|
[tkKey, tkSpace, tkIdentifier, tkSymbol { : }, tkSpace, tkIdentifier, tkSpace,
|
|
tkKey { read }, tkSpace, tkIdentifier, tkSymbol { ; }, tkSpace, tkModifier {the one and only}, tkSymbol
|
|
]);
|
|
CheckTokensForLine('procedure in class-sect', 10,
|
|
[tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol { ( }, tkIdentifier, tkSymbol { : },
|
|
tkSpace, tkIdentifier, tkSymbol { ) }, tkSymbol, tkSpace, tkModifier {the one and only}, tkSymbol
|
|
]);
|
|
|
|
end;
|
|
|
|
begin
|
|
PushBaseName('test for '+s);
|
|
ReCreateEdit;
|
|
EnableFolds(AEnbledTypes, AHideTypes, ANoFoldTypes);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'var',
|
|
s+': '+s+' '+s+';', // nameDEPRECATED: typeDEPRECATED deprecated;
|
|
'foo, '+s+', bar: Integer '+s+';',
|
|
'type',
|
|
s+' = '+s+' '+s+';', // nameDEPRECATED = typeDEPRECATED deprecated;
|
|
s+' =type '+s+' '+s+';', // nameDEPRECATED = type typeDEPRECATED deprecated;
|
|
'procedure '+s+'('+s+': '+s+'); '+s+';',
|
|
'var',
|
|
s+':procedure '+s+';',
|
|
'',
|
|
'type tfoo = class',
|
|
// 12
|
|
'procedure bar; message 1; '+s+';',
|
|
'procedure bar; message A; '+s+';',
|
|
'procedure bar; message ''x''; '+s+';',
|
|
'procedure bar; message #01; '+s+';',
|
|
'end;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('var', 2,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('multi var', 3,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace,tkIdentifier, tkSymbol, // ... ":"
|
|
tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('type', 5,
|
|
[tkIdentifier, tkSpace, tkSymbol, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('type', 6,
|
|
[tkIdentifier, tkSpace, tkSymbol, tkKey, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('procedure', 7,
|
|
[tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol { ( }, tkIdentifier, tkSymbol { : },
|
|
tkSpace, tkIdentifier, tkSymbol { ) }, tkSymbol, tkSpace, tkModifier {the one and only}, tkSymbol
|
|
]);
|
|
CheckTokensForLine('var a:procedure DEPRECATED;', 9,
|
|
[tkIdentifier, TK_Colon, tkKey, tkSpace, tkModifier {the one and only}, TK_Semi]);
|
|
|
|
CheckTokensForLine('procedure bar; message 1; DEPRECATED;', 12,
|
|
[tkKey, tkSpace, tkIdentifier+FAttrProcName, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkNumber, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure bar; message A; DEPRECATED;', 13,
|
|
[tkKey, tkSpace, tkIdentifier+FAttrProcName, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure bar; message ''X''; DEPRECATED;', 14,
|
|
[tkKey, tkSpace, tkIdentifier+FAttrProcName, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkString, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure bar; message ''X''; DEPRECATED;', 15,
|
|
[tkKey, tkSpace, tkIdentifier+FAttrProcName, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkString, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
|
|
|
|
PushBaseName('class');
|
|
SubTest2('class');
|
|
PushBaseName('class public');
|
|
SubTest2('class public');
|
|
PopPushBaseName('object');
|
|
SubTest2('object');
|
|
PopPushBaseName('object public');
|
|
SubTest2('object public');
|
|
PopPushBaseName('record');
|
|
SubTest2('record');
|
|
PopPushBaseName('record public');
|
|
SubTest2('record public');
|
|
|
|
PopPushBaseName('record case integer of 1:(');
|
|
SubTest2('record case integer of 1:(');
|
|
PopPushBaseName('record case integer of 1:( B:record case integer of 2:(');
|
|
SubTest2('record case integer of 1:( B:record case integer of 2:(');
|
|
PopPushBaseName('var/type');
|
|
SubTest2('byte;var');
|
|
PopBaseName;
|
|
|
|
|
|
SetLines
|
|
([ 'Program a',
|
|
'procedure '+s+'('+s+': '+s+');',
|
|
'var',
|
|
s+': '+s+' '+s+';', // nameDEPRECATED: typeDEPRECATED deprecated;
|
|
'foo, '+s+', bar: Integer '+s+';',
|
|
'begin end;',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('procedure in implement', 1,
|
|
[tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol { ( }, tkIdentifier, tkSymbol { : },
|
|
tkSpace, tkIdentifier, tkSymbol { ) }, tkSymbol
|
|
]);
|
|
CheckTokensForLine('var in procedure', 3,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
CheckTokensForLine('multi var in procedure', 4,
|
|
[tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace,tkIdentifier, tkSymbol, // ... ":"
|
|
tkSpace, tkIdentifier, tkSpace, tkModifier {the one and only}, tkSymbol]);
|
|
|
|
|
|
|
|
// after class declaration
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'TFoo=class',
|
|
'foo: Integer;',
|
|
'end '+s+';',
|
|
''
|
|
]);
|
|
CheckTokensForLine('after class declaration', 4,
|
|
[tkKey, tkSpace, tkModifier , tkSymbol]);
|
|
|
|
|
|
// after unit declaration
|
|
SetLines
|
|
([ 'Unit A nonkey;', // check wrong word - must not be key
|
|
'interface uses foo;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('dummy word after unit', 0,
|
|
[tkKey, tkSpace, tkIdentifier, tkSpace, tkIdentifier, tkSymbol]);
|
|
|
|
SetLines
|
|
([ 'Unit A;'+s+';', // must not be key
|
|
'interface uses foo;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('after unit, but after semicolon', 0,
|
|
[tkKey, tkSpace, tkIdentifier, tkSymbol, tkIdentifier, tkSymbol]);
|
|
|
|
SetLines
|
|
([ 'Unit A '+s+';',
|
|
'interface uses foo;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('after unit', 0,
|
|
[tkKey, tkSpace, tkIdentifier, tkSpace, tkModifier, tkSymbol]);
|
|
CheckTokensForLine('after unit - next line', 1,
|
|
[tkKey, tkSpace, tkKey, tkSpace, tkIdentifier, tkSymbol]);
|
|
|
|
SetLines
|
|
([ 'Unit A.B '+s+';',
|
|
'interface uses foo;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('after dotted unit', 0,
|
|
[tkKey, tkSpace, tkIdentifier, tkSymbol, tkIdentifier, tkSpace, tkModifier, tkSymbol]);
|
|
CheckTokensForLine('after unit - next line', 1,
|
|
[tkKey, tkSpace, tkKey, tkSpace, tkIdentifier, tkSymbol]);
|
|
|
|
|
|
PopBaseName;
|
|
end;
|
|
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to $40-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtVarBlock, cfbtLocalVarBlock];
|
|
if (i and $08) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
if (i and $10) = 0 then AFolds := AFolds - [cfbtClassSection];
|
|
if (i and $20) = 0 then AFolds := AFolds - [cfbtProcedure];
|
|
//if (i and $40) = 0 then AFolds := AFolds - [cfbtAnonymousProcedure];
|
|
SubTest('deprecated' , AFolds);
|
|
SubTest('unimplemented', AFolds);
|
|
SubTest('experimental' , AFolds);
|
|
SubTest('platform' , AFolds);
|
|
end;
|
|
SubTest('deprecated' , []);
|
|
SubTest('unimplemented', []);
|
|
SubTest('experimental' , []);
|
|
SubTest('platform' , []);
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForClassObjRecHelp;
|
|
var
|
|
i0, i1, i2, i3, i4: Integer;
|
|
s0, s1, s2: String;
|
|
begin
|
|
ReCreateEdit;
|
|
EnableFolds([cfbtClass, cfbtRecord], []);
|
|
|
|
for i0 := 0 to 9 do
|
|
for i1 := 0 to 5 do
|
|
for i2 := 0 to 1 do
|
|
for i3 := 0 to 1 do
|
|
for i4 := 0 to 3 do
|
|
begin
|
|
if (i1 = 3) and (i2 = 1) then // type type helper
|
|
continue;
|
|
|
|
case i0 of
|
|
0: s0 := '';
|
|
1: s0 := 'TSome = class type';
|
|
2: s0 := 'TSome = class public type';
|
|
3: s0 := 'TSome = class var a: integer; type';
|
|
4: s0 := 'TSome = object type';
|
|
5: s0 := 'TSome = object public type';
|
|
6: s0 := 'TSome = object var a: integer; type';
|
|
7: s0 := 'TSome = record type';
|
|
8: s0 := 'TSome = record public type';
|
|
9: s0 := 'TSome = record var a: integer; type';
|
|
// TODO: nested in record-case
|
|
//10: s0 := 'TSome = record case integer of 1: ( a: record b: integer; type'; // BracketNestLevel inside record-case
|
|
end;
|
|
|
|
case i4 of
|
|
0: s1 := 'TFoo = ';
|
|
1: s1 := 'TFoo=';
|
|
2: s1 := 'generic TFoo<A> = ';
|
|
3: s1 := 'generic TFoo<A>=';
|
|
end;
|
|
|
|
case i1 of
|
|
0: s2 := 'class';
|
|
1: s2 := 'record';
|
|
2: s2 := 'object';
|
|
3: s2 := 'type helper for integer';
|
|
4: s2 := 'class helper for TFoo';
|
|
5: s2 := 'record helper for TBar';
|
|
end;
|
|
if i2 = 1 then s2 := 'type '+s2;
|
|
if i3 = 1 then s2 := ' '+s2; // leading space
|
|
|
|
SetLines
|
|
([ 'Unit A; interface {$modeswitch advancedrecords}{$modeswitch typehelpers}', // 0
|
|
'type',
|
|
s0,
|
|
'',
|
|
s1,
|
|
s2, // 5
|
|
'public',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
AssertEquals(1, FTheHighLighter.FoldOpenCount(5)); // fold opens for class/record/...
|
|
AssertEquals(7, FTheHighLighter.FoldEndLine(5, 0)); // fold end for class/record/...
|
|
end;
|
|
|
|
|
|
|
|
for i2 := 0 to 1 do
|
|
for i3 := 0 to 1 do
|
|
for i4 := 0 to 1 do
|
|
begin
|
|
|
|
case i4 of
|
|
0: s1 := 'TFoo : ';
|
|
1: s1 := 'TFoo:';
|
|
end;
|
|
|
|
s2 := 'record';
|
|
if i2 = 1 then s2 := 'type '+s2;
|
|
if i3 = 1 then s2 := ' '+s2; // leading space
|
|
SetLines
|
|
([ 'Unit A; interface {$modeswitch advancedrecords}{$modeswitch typehelpers}', // 0
|
|
'var',
|
|
'',
|
|
'',
|
|
s1,
|
|
s2, // 5
|
|
'public',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
AssertEquals(1, FTheHighLighter.FoldOpenCount(5)); // fold opens for class/record/...
|
|
AssertEquals(7, FTheHighLighter.FoldEndLine(5, 0)); // fold end for class/record/...
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForClassSection;
|
|
var
|
|
ty, rc, rc1, hlp, lead1, lead2, cm, s1, s2, v, v_t: string;
|
|
strict1, strict2: Boolean;
|
|
cmod, sp1, sp2: Integer;
|
|
begin
|
|
ReCreateEdit;
|
|
for ty in [' ', 'type '] do
|
|
for rc1 in ['class ', 'object', 'record'] do
|
|
for hlp in [' ', ' helper for c ', ' helper(b) for c '] do
|
|
for lead1 in ['', ' '] do
|
|
for lead2 in ['', ' '] do
|
|
for cm in [' ', ' sealed abstract', ' sealed ', ' abstract '] do
|
|
for s1 in ['strict private ', 'strict protected', 'private ', 'protected ', 'public ', 'published '] do
|
|
for s2 in ['strict private ', 'strict protected', 'private ', 'protected ', 'public ', 'published '] do
|
|
for v in ['private ', 'protected ', 'public ', 'published '] do
|
|
begin
|
|
rc := rc1;
|
|
sp1 := ord(tkSpace);
|
|
if lead1 = '' then sp1 := TK_SKIP;
|
|
sp2 := ord(tkSpace);
|
|
if lead2 = '' then sp2 := TK_SKIP;
|
|
|
|
strict1 := s1[1] = 's';
|
|
strict2 := s2[1] = 's';
|
|
cmod := 0;
|
|
if cm[2] <> ' ' then
|
|
case cm[9] of
|
|
' ': cmod := 1; // sealed
|
|
'a': cmod := 2; // sealed abstract
|
|
't': cmod := 1; // abstract
|
|
end;
|
|
|
|
if (hlp[2]<>' ') and
|
|
( (ty[1] <> ' ') or (cm[2] <> ' ') )
|
|
then
|
|
continue;
|
|
|
|
if (hlp[2]<>' ') and (rc = 'object') then // no "object helper" // make it "type helper"
|
|
rc := 'type';
|
|
|
|
if (rc <> 'class ') and ( (cmod <> 0) or strict1 or strict2 )
|
|
then
|
|
continue;
|
|
|
|
//ReCreateEdit;
|
|
v_t := trim(v);
|
|
SetLines
|
|
([ 'Unit A; interface {$mode objfpc} {$modeswitch typehelpers} {$modeswitch advancedrecords}', // 0
|
|
'type',
|
|
'TFoo='+ty+rc+hlp+cm , // 2 class sealed abstract
|
|
lead1+trim(s1),
|
|
lead2+trim(s2),
|
|
'a,'+v_t+':'+v_t+';', // 5
|
|
lead1+trim(s2),
|
|
lead2+trim(s1),
|
|
'function '+v_t+'('+v_t+':'+v_t+';'+v_t+','+v_t+':'+v_t+'):'+v_t+';', // 8
|
|
lead1+trim(s1),
|
|
lead2+trim(s2), //10
|
|
'end;',
|
|
lead1+v_t+'='+v_t+';', // 12
|
|
lead2+v_t+'='+v_t+';',
|
|
'var',
|
|
lead1+v_t+':'+v_t+';', // 15
|
|
lead2+v_t+':'+v_t+';',
|
|
''
|
|
]);
|
|
|
|
if hlp[2]=' ' then begin // not a helper
|
|
if ty[1] = ' ' then begin
|
|
case cmod of
|
|
0: CheckTokensForLine('TFoo=class', 2, [ tkIdentifier, tkSymbol, tkSpace, tkKey ]);
|
|
1: CheckTokensForLine('TFoo=class', 2, [ tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkModifier, tkSpace ]);
|
|
2: CheckTokensForLine('TFoo=class', 2, [ tkIdentifier, tkSymbol, tkSpace, tkKey, tkSpace, tkModifier, tkSpace, tkModifier]);
|
|
end;
|
|
end
|
|
else begin
|
|
case cmod of
|
|
0: CheckTokensForLine('TFoo=class', 2, [ tkIdentifier, tkSymbol, tkKey, tkSpace, tkKey ]);
|
|
1: CheckTokensForLine('TFoo=class', 2, [ tkIdentifier, tkSymbol, tkKey, tkSpace, tkKey, tkSpace, tkModifier, tkSpace ]);
|
|
2: CheckTokensForLine('TFoo=class', 2, [ tkIdentifier, tkSymbol, tkKey, tkSpace, tkKey, tkSpace, tkModifier, tkSpace, tkModifier]);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
case strict1 of
|
|
False: CheckTokensForLine('public', 3, [ sp1, tkKey ]);
|
|
True: CheckTokensForLine('strict private', 3, [ sp1, tkKey, tkSpace, tkKey ]);
|
|
end;
|
|
case strict2 of
|
|
False: CheckTokensForLine('public', 4, [ sp2, tkKey ]);
|
|
True: CheckTokensForLine('strict private', 4, [ sp2, tkKey, tkSpace, tkKey ]);
|
|
end;
|
|
|
|
CheckTokensForLine('a,public:public;', 5,
|
|
[ tkIdentifier {a}, tkSymbol{,}, tkIdentifier {public}, tkSymbol{:},
|
|
tkIdentifier, tkSymbol{;} ]);
|
|
|
|
case strict2 of
|
|
False: CheckTokensForLine('public', 6, [ sp1, tkKey ]);
|
|
True: CheckTokensForLine('strict private', 6, [ sp1, tkKey, tkSpace, tkKey ]);
|
|
end;
|
|
case strict1 of
|
|
False: CheckTokensForLine('public', 7, [ sp2, tkKey ]);
|
|
True: CheckTokensForLine('strict private', 7, [ sp2, tkKey, tkSpace, tkKey ]);
|
|
end;
|
|
|
|
|
|
CheckTokensForLine('function ...', 8,
|
|
[ tkKey {function}, tkSpace, tkIdentifier + FAttrProcName{public},tkSymbol{(},
|
|
tkIdentifier {public}, tkSymbol{:}, tkIdentifier, tkSymbol{;},
|
|
tkIdentifier {public}, tkSymbol{,}, tkIdentifier {public}, tkSymbol{:}, tkIdentifier, tkSymbol{;},
|
|
tkSymbol{)}, tkIdentifier, tkSymbol{;}
|
|
]);
|
|
|
|
case strict1 of
|
|
False: CheckTokensForLine('public', 9, [ sp1, tkKey ]);
|
|
True: CheckTokensForLine('strict private', 9, [ sp1, tkKey, tkSpace, tkKey ]);
|
|
end;
|
|
case strict2 of
|
|
False: CheckTokensForLine('public', 10, [ sp2, tkKey ]);
|
|
True: CheckTokensForLine('strict private', 10, [ sp2, tkKey, tkSpace, tkKey ]);
|
|
end;
|
|
|
|
CheckTokensForLine('end', 11, [ tkKey, tkSymbol ]);
|
|
|
|
CheckTokensForLine('public=public;', 12,
|
|
[ sp1, tkIdentifier {public}, tkSymbol{=}, tkIdentifier, tkSymbol{;} ]);
|
|
CheckTokensForLine('public=public;', 13,
|
|
[ sp2, tkIdentifier {public}, tkSymbol{=}, tkIdentifier, tkSymbol{;} ]);
|
|
|
|
CheckTokensForLine('var', 14, [ tkKey ]);
|
|
|
|
CheckTokensForLine('public:public;', 15,
|
|
[ sp1, tkIdentifier {public}, tkSymbol{:}, tkIdentifier, tkSymbol{;} ]);
|
|
// public would be modifier
|
|
if trim(v) <> 'public' then
|
|
CheckTokensForLine('public:public;', 16,
|
|
[ sp2, tkIdentifier {public}, tkSymbol{:}, tkIdentifier, tkSymbol{;} ]);
|
|
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForClassModifier;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to $08-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'TFoo = class sealed abstract',
|
|
'a, sealed, abstract: Integer;',
|
|
'procedure Foo; abstract;',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('class declaration"', 2,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {class}, tkSpace,
|
|
tkModifier {sealed}, tkSpace, tkModifier {abstract}
|
|
]);
|
|
CheckTokensForLine('var in class "', 3,
|
|
[ tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol,
|
|
tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
CheckTokensForLine('procedure in class "', 4,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkSpace, tkModifier, tkSymbol ]);
|
|
|
|
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'TFoo = class {} sealed abstract',
|
|
'a, sealed, abstract: Integer;',
|
|
'procedure Foo; abstract;',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('class declaration"', 2,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {class}, tkSpace, tkComment, tkSpace,
|
|
tkModifier {sealed}, tkSpace, tkModifier {abstract}
|
|
]);
|
|
CheckTokensForLine('var in class "', 3,
|
|
[ tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol,
|
|
tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
CheckTokensForLine('procedure in class "', 4,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkSpace, tkModifier, tkSymbol ]);
|
|
|
|
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'TFoo = class {}',
|
|
' sealed abstract',
|
|
'helper, sealed, abstract: Integer;',
|
|
'procedure Foo; abstract;',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('class declaration"', 2,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {class}, tkSpace, tkComment
|
|
]);
|
|
CheckTokensForLine('class declaration"', 3,
|
|
[ tkSpace, tkModifier {sealed}, tkSpace, tkModifier {abstract}
|
|
]);
|
|
CheckTokensForLine('var in class "', 4,
|
|
[ tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol,
|
|
tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
CheckTokensForLine('procedure in class "', 5,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkSpace, tkModifier, tkSymbol ]);
|
|
|
|
|
|
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'TFoo = class sealed abstract(sealed)',
|
|
'helper, sealed, abstract: Integer;',
|
|
'procedure Foo; abstract;',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('class declaration"', 2,
|
|
[ tkIdentifier, tkSpace, TK_Equal, tkSpace,
|
|
tkKey {class}, tkSpace,
|
|
tkModifier {sealed}, tkSpace, tkModifier {abstract},
|
|
tkSymbol, tkIdentifier, tkSymbol
|
|
]);
|
|
CheckTokensForLine('var in class "', 3,
|
|
[ tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol,
|
|
tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
CheckTokensForLine('procedure in class "', 4,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkSpace, tkModifier, tkSymbol ]);
|
|
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForClassOf;
|
|
procedure SetClassOfText(s: String; s2: String = '');
|
|
begin
|
|
if s2 = '' then s2 := 'FInt1: String;';
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
s, // 2
|
|
s2, // 3
|
|
'FInt: String;', // 4
|
|
'private', // 5
|
|
'procedure Foo; abstract;',
|
|
'end;',
|
|
''
|
|
]);
|
|
end;
|
|
procedure CheckClassOfField(ALine: Integer);
|
|
begin
|
|
CheckTokensForLine('Fint: integer; '+IntToStr(ALine), ALine, [ tkIdentifier, TK_Colon, tkSpace, tkKey, TK_Semi ]);
|
|
AssertEquals('no Fold-OpenCount '+IntToStr(ALine), 0, FTheHighLighter.FoldOpenCount(ALine));
|
|
end;
|
|
procedure CheckClassOfFold(ALine: Integer; AFold: Boolean);
|
|
begin
|
|
AssertEquals('Fold-OpenCount 2', 1, FTheHighLighter.FoldOpenCount(2)); // currently always
|
|
|
|
if AFold then begin
|
|
CheckTokensForLine('private '+IntToStr(ALine), ALine, [ tkKey ]);
|
|
AssertEquals('Fold-OpenCount '+IntToStr(ALine), 1, FTheHighLighter.FoldOpenCount(ALine));
|
|
end
|
|
else begin
|
|
CheckTokensForLine('private '+IntToStr(ALine), ALine, [ tkIdentifier ]);
|
|
AssertEquals('no Fold-OpenCount '+IntToStr(ALine), 0, FTheHighLighter.FoldOpenCount(ALine));
|
|
end;
|
|
end;
|
|
begin
|
|
ReCreateEdit;
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]);
|
|
|
|
SetClassOfText('TFoo=class');
|
|
CheckClassOfField(3);
|
|
CheckClassOfFold(5, True);
|
|
|
|
SetClassOfText('TFoo=class(TFoo)');
|
|
CheckClassOfField(3);
|
|
CheckClassOfFold(5, True);
|
|
|
|
SetClassOfText('TFoo=class()');
|
|
CheckClassOfField(3);
|
|
CheckClassOfFold(5, True);
|
|
|
|
SetClassOfText('TFoo=class()', 'private'); // incomplete
|
|
CheckClassOfFold(3, True);
|
|
CheckClassOfField(4);
|
|
CheckClassOfFold(5, True);
|
|
|
|
|
|
SetClassOfText('TFoo=class of');
|
|
CheckClassOfField(3);
|
|
CheckClassOfFold(5, False);
|
|
|
|
SetClassOfText('TFoo=class {bar} of');
|
|
CheckClassOfField(3);
|
|
CheckClassOfFold(5, False);
|
|
|
|
SetClassOfText('TFoo=class of', 'private');
|
|
CheckClassOfFold(3, False);
|
|
CheckClassOfField(4);
|
|
CheckClassOfFold(5, False);
|
|
|
|
|
|
SetClassOfText('TFoo = class sealed (TBar) of');
|
|
CheckClassOfField(3);
|
|
CheckClassOfFold(5, True);
|
|
|
|
SetClassOfText('TFoo = class sealed of');
|
|
CheckClassOfField(3);
|
|
CheckClassOfFold(5, True);
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForClassProcModifier;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i, j: Integer;
|
|
n: String;
|
|
h: TSynHighlighterAttributesModifier;
|
|
begin
|
|
ReCreateEdit;
|
|
h := FAttrProcName;
|
|
for i := 0 to 8 do begin
|
|
case i of
|
|
0: n := 'virtual';
|
|
1: n := 'dynamic';
|
|
2: n := 'override';
|
|
3: n := 'abstract';
|
|
4: n := 'final';
|
|
5: n := 'reintroduce';
|
|
6: n := 'message';
|
|
7: n := 'platform';
|
|
8: n := 'overload';
|
|
9: n := 'enumerator'; // "enumerator current" or "enumerator MoveNext"
|
|
end;
|
|
|
|
SetLines
|
|
([ 'Unit A; interface {$mode delphi}',
|
|
'type',
|
|
'TFoo = class public',
|
|
// 3
|
|
n+':'+n+';'+n+':'+n+';', // 2 fields
|
|
'public',
|
|
// 5
|
|
n+':'+n+' deprecated;'+n+','+n+':'+n+';', // 3 fields
|
|
'public',
|
|
// 7
|
|
n+':procedure;'+n+':'+n+';', //
|
|
n+':procedure deprecated;'+n+':'+n+';', //
|
|
'',
|
|
'',
|
|
// 11
|
|
'procedure '+n+';'+n+';',
|
|
'procedure '+n+';deprecated; '+n+';', // deprecated before virtual: ONLY mode delphi
|
|
'procedure '+n+'; '+n+'; deprecated;',
|
|
'procedure '+n+';overload; '+n+';',
|
|
'procedure '+n+'; '+n+'; overload;',
|
|
'',
|
|
// 17
|
|
'procedure '+n+'; override; final;',
|
|
'procedure '+n+'; virtual; final;',
|
|
'procedure '+n+'; reintroduce; virtual;',
|
|
'procedure '+n+'; reintroduce; virtual; final;',
|
|
'procedure '+n+'; overload; reintroduce; virtual; final;',
|
|
'procedure '+n+'; reintroduce; virtual; final; overload;',
|
|
'procedure '+n+'; reintroduce; virtual; final; deprecated;',
|
|
'',
|
|
// 25
|
|
'procedure '+n+'; message A; '+n+';',
|
|
'procedure '+n+'; message 1; '+n+';',
|
|
'procedure '+n+'; message ''x''; '+n+';',
|
|
'procedure '+n+'; message #01; '+n+';',
|
|
'procedure '+n+'; message '+n+'; '+n+';',
|
|
// 30
|
|
'procedure '+n+'; '+n+'; message A;',
|
|
'procedure '+n+'; '+n+'; message 1;',
|
|
'procedure '+n+'; '+n+'; message ''x'';',
|
|
'procedure '+n+'; '+n+'; message '+n+';',
|
|
// 34
|
|
'procedure '+n+'; override; message A;final;',
|
|
'procedure '+n+'; override; message 1;final;',
|
|
'procedure '+n+'; override; message ''x'';final;',
|
|
'procedure '+n+'; override; message '+n+';final;',
|
|
// 38
|
|
'procedure '+n+'('+n+':'+n+');'+n+';',
|
|
'function '+n+':'+n+';'+n+';',
|
|
'function '+n+'('+n+':'+n+'):'+n+';'+n+';',
|
|
// 41
|
|
'function '+n+'('+n+':'+n+'):'+n+';enumerator MoveNext;'+n+';',
|
|
'property '+n+':'+n+' read '+n+';enumerator Current;deprecated;',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
for j := 0 to $0F do begin
|
|
AFolds := [];
|
|
if (j and $08) = 0 then AFolds := [cfbtBeginEnd..cfbtNone] - [cfbtClass, cfbtClassSection, cfbtProcedure];
|
|
if (j and $01) = 0 then AFolds := AFolds + [cfbtClass];
|
|
if (j and $02) = 0 then AFolds := AFolds + [cfbtClassSection];
|
|
if (j and $04) = 0 then AFolds := AFolds + [cfbtProcedure];
|
|
|
|
EnableFolds(AFolds);
|
|
|
|
CheckTokensForLine(n+':'+n+';'+n+':'+n+';', 3,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, TK_Semi,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine( 'public', 4, [tkKey]);
|
|
// 5
|
|
CheckTokensForLine( n+':'+n+' deprecated;'+n+','+n+':'+n+';', 5,
|
|
[tkIdentifier, TK_Colon, tkIdentifier, tkSpace, tkModifier, TK_Semi,
|
|
tkIdentifier, TK_Comma, tkIdentifier, TK_Colon, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine( 'public', 6, [tkKey]);
|
|
// 7
|
|
CheckTokensForLine( n+':procedure;'+n+':'+n+';', 7,
|
|
[tkIdentifier, TK_Colon, tkKey, TK_Semi,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine( n+':procedure deprecated;'+n+':'+n+';', 8,
|
|
[tkIdentifier, TK_Colon, tkKey, tkSpace, tkModifier, TK_Semi,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi]);
|
|
// 11
|
|
CheckTokensForLine('procedure '+n+';'+n+';', 11,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkModifier, TK_Semi]);
|
|
// deprecated before virtual: ONLY mode delphi
|
|
CheckTokensForLine('procedure '+n+';deprecated; '+n+';', 12,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; '+n+'; deprecated;', 13,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+';overload; '+n+';', 14,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; '+n+'; overload;', 15,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
// 17
|
|
CheckTokensForLine('procedure '+n+'; override; final;', 17,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; virtual; final;', 18,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; reintroduce; virtual;', 19,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; reintroduce; virtual; final;', 20,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; overload; reintroduce; virtual; final;', 21,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; reintroduce; virtual; final; overload;', 22,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; reintroduce; virtual; final; deprecated;', 23,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi, tkSpace, tkModifier, TK_Semi]);
|
|
// 25
|
|
CheckTokensForLine('procedure '+n+'; message A; '+n+';',25,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; message 1; '+n+';',26,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkNumber, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; message ''x''; '+n+';',27,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkString, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; message #01; '+n+';',28,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkString, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi]);
|
|
CheckTokensForLine('procedure '+n+'; message '+n+'; '+n+';',29,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi]);
|
|
// 30
|
|
CheckTokensForLine('procedure '+n+'; '+n+'; message A;',30,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure '+n+'; '+n+'; message 1;',31,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkNumber, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure '+n+'; '+n+'; message ''x'';',32,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkString, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure '+n+'; '+n+'; message '+n+';',33,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi
|
|
]);
|
|
// 34
|
|
CheckTokensForLine('procedure '+n+'; override; message A;final;',34,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure '+n+'; override; message 1;final;',35,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkNumber, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure '+n+'; override; message ''x'';final;',36,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkString, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('procedure '+n+'; override; message '+n+';final;',37,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Semi,
|
|
tkSpace, tkModifier, TK_Semi,
|
|
tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
// 38
|
|
CheckTokensForLine('procedure '+n+'('+n+':'+n+');'+n+';',38,
|
|
[tkKey, tkSpace, tkIdentifier+h,
|
|
TK_Bracket, tkIdentifier, TK_Comma, tkIdentifier, TK_Bracket, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('function '+n+':'+n+';'+n+';',39,
|
|
[tkKey, tkSpace, tkIdentifier+h, TK_Colon,
|
|
tkIdentifier, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('function '+n+'('+n+':'+n+'):'+n+';'+n+';',40,
|
|
[tkKey, tkSpace, tkIdentifier+h,
|
|
TK_Bracket, tkIdentifier, TK_Comma, tkIdentifier, TK_Bracket, TK_Colon,
|
|
tkIdentifier, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
// 41
|
|
CheckTokensForLine('function '+n+'('+n+':'+n+'):'+n+';enumerator MoveNext;'+n+';',41,
|
|
[tkKey, tkSpace, tkIdentifier+h,
|
|
TK_Bracket, tkIdentifier, TK_Comma, tkIdentifier, TK_Bracket, TK_Colon, tkIdentifier, TK_Semi,
|
|
tkModifier, tkSpace, tkIdentifier, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
CheckTokensForLine('property '+n+':'+n+' read '+n+';enumerator Current;deprecated;',42,
|
|
[tkKey, tkSpace, tkIdentifier,
|
|
TK_Colon, tkIdentifier, tkSpace, tkKey, tkSpace, tkIdentifier, TK_Semi,
|
|
tkModifier, tkSpace, tkIdentifier, TK_Semi,
|
|
tkModifier, TK_Semi
|
|
]);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForClassHelper;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to $08-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'TFoo = class helper for TBar',
|
|
'helper, sealed, abstract, public: Integer;',
|
|
'procedure Foo; abstract;',
|
|
'end;',
|
|
'TFoo = class helper for TBar',
|
|
'protected',
|
|
'end;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('class declaration"', 2,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {class}, tkSpace, tkKey {helper}, tkSpace, tkKey {for},
|
|
tkSpace, tkIdentifier
|
|
]);
|
|
CheckTokensForLine('var in class "', 3,
|
|
[ tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace,
|
|
tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol,
|
|
tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
CheckTokensForLine('procedure in class "', 4,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkSpace, tkModifier, tkSymbol ]);
|
|
CheckTokensForLine('end', 5,
|
|
[ tkKey, tkSymbol ]);
|
|
CheckTokensForLine('class declaration"', 6,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {class}, tkSpace, tkKey {helper}, tkSpace, tkKey {for},
|
|
tkSpace, tkIdentifier
|
|
]);
|
|
CheckTokensForLine('class section', 7,
|
|
[ tkKey ]);
|
|
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'TFoo = class helper(helper) for helper',
|
|
'helper, sealed, abstract: Integer;',
|
|
'procedure Foo; abstract;',
|
|
'end;',
|
|
'TFoo = class helper(helper) for helper',
|
|
'protected',
|
|
''
|
|
]);
|
|
CheckTokensForLine('class declaration"', 2,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {class}, tkSpace, tkKey {helper}, tkSymbol, tkIdentifier, tkSymbol,
|
|
tkSpace, tkKey {for},
|
|
tkSpace, tkIdentifier
|
|
]);
|
|
CheckTokensForLine('var in class "', 3,
|
|
[ tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol,
|
|
tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
CheckTokensForLine('procedure in class "', 4,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkSpace, tkModifier, tkSymbol ]);
|
|
CheckTokensForLine('class section', 7,
|
|
[ tkKey ]);
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForTypeHelper;
|
|
procedure DoChecks;
|
|
begin
|
|
CheckTokensForLine('not a helper', 2,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {type}, tkSpace, tkIdentifier {helper}, tkSpace, tkKey {for}, tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
AssertEquals('not a helper / no fold', 0, PasHighLighter.FoldOpenCount(2));
|
|
|
|
CheckTokensForLine('helper', 5,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {type}, tkSpace, tkKey {helper}, tkSpace, tkKey {for}, tkSpace, tkIdentifier
|
|
]);
|
|
CheckTokensForLine('procedure in helper', 6,
|
|
[ tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkSpace, tkModifier, tkSymbol ]);
|
|
CheckTokensForLine('uniq type', 8,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {type}, tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
AssertEquals('uniq type / no fold', 0, PasHighLighter.FoldOpenCount(8));
|
|
|
|
CheckTokensForLine('not a helper, switched off', 11,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {type}, tkSpace, tkIdentifier {helper}, tkSpace, tkKey {for}, tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
AssertEquals('not a helper, switched off / no fold', 0, PasHighLighter.FoldOpenCount(11));
|
|
|
|
CheckTokensForLine('class section', 14,
|
|
[ tkKey ]);
|
|
CheckTokensForLine('NOT class section', 18,
|
|
[ tkIdentifier ]);
|
|
end;
|
|
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to $08-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; {$mode objfpc} interface',
|
|
'type',
|
|
'helper = type helper for helper;',
|
|
'type',
|
|
'{$modeswitch typehelpers}',
|
|
'helper = type helper for helper',
|
|
'procedure Foo; static;',
|
|
'end;',
|
|
'helper = type integer;',
|
|
'type',
|
|
'{$modeswitch typehelpers-}',
|
|
'helper = type helper for helper;',
|
|
'{$modeswitch typehelpers}',
|
|
'helper = type helper for helper',
|
|
'protected',
|
|
'end;',
|
|
'{$modeswitch typehelpers-}',
|
|
'helper = type helper for helper',
|
|
'protected',
|
|
'{$modeswitch typehelpers}',
|
|
''
|
|
]);
|
|
|
|
DoChecks;
|
|
SynEdit.TestTypeText(1, 2, ' ');
|
|
DoChecks; // modeswitch on rescan
|
|
|
|
PasHighLighter.FoldConfig[ord(cfbtClass)].Enabled := False;
|
|
DoChecks;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForClassFunction;
|
|
var
|
|
i, j: Integer;
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
const
|
|
t: array[0..2] of string = ('class', 'object', 'record');
|
|
begin
|
|
for i := 0 to $08-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
|
|
for j:= 0 to 2 do begin
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'TFoo = '+t[j],
|
|
'class function f1: boolean;',
|
|
'class procedure p1(v: boolean);',
|
|
'end;',
|
|
''
|
|
]);
|
|
// unit/iface, type, record, -,-
|
|
if i = $08-1 then
|
|
CheckFoldOpenCounts('', [2, 1, 1, 0, 0]);
|
|
|
|
CheckTokensForLine('class function', 3,
|
|
[ tkKey, tkSpace, tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkSpace, tkIdentifier, tkSymbol ]);
|
|
CheckTokensForLine('class procedure', 4,
|
|
[ tkKey, tkSpace, tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSymbol ]);
|
|
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForRecordHelper;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to $08-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface {$mode delphi}',
|
|
'type',
|
|
'TFoo = record helper for TBar',
|
|
'helper, sealed, abstract: Integer;',
|
|
'end;',
|
|
'TFoo = record helper for TBar',
|
|
'protected;',
|
|
'end;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('record declaration"', 2,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {class}, tkSpace, tkKey {helper}, tkSpace, tkKey {for},
|
|
tkSpace, tkIdentifier
|
|
]);
|
|
CheckTokensForLine('var in class "', 3,
|
|
[ tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol,
|
|
tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
CheckTokensForLine('class section', 6,
|
|
[ tkKey ]);
|
|
|
|
|
|
ReCreateEdit;
|
|
EnableFolds(AFolds);
|
|
SetLines
|
|
([ 'Unit A; interface {$mode delphi}',
|
|
'type',
|
|
'TFoo = record helper(helper) for helper',
|
|
'helper, sealed, abstract: Integer;',
|
|
'end;',
|
|
''
|
|
]);
|
|
CheckTokensForLine('record declaration"', 2,
|
|
[ tkIdentifier, tkSpace, tkSymbol, tkSpace,
|
|
tkKey {class}, tkSpace, tkKey {helper}, tkSymbol, tkIdentifier, tkSymbol,
|
|
tkSpace, tkKey {for},
|
|
tkSpace, tkIdentifier
|
|
]);
|
|
CheckTokensForLine('var in class "', 3,
|
|
[ tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol,
|
|
tkSpace, tkIdentifier, tkSymbol
|
|
]);
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForRecordCase;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to $1F do begin
|
|
AFolds := [];
|
|
if (i and $10) = 0 then AFolds := [cfbtBeginEnd..cfbtNone] - [cfbtVarBlock, cfbtRecord, cfbtRecordCase, cfbtRecordCaseSection];
|
|
if (i and $01) = 0 then AFolds := AFolds + [cfbtVarBlock];
|
|
if (i and $02) = 0 then AFolds := AFolds + [cfbtRecord];
|
|
if (i and $04) = 0 then AFolds := AFolds + [cfbtRecordCase];
|
|
if (i and $08) = 0 then AFolds := AFolds + [cfbtRecordCaseSection];
|
|
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
' TFoo = record',
|
|
' A:byte;',
|
|
' case integer of',
|
|
' 1: (',
|
|
' B: record',
|
|
' case integer of',
|
|
' 3: (',
|
|
' );',
|
|
' 4: (',
|
|
' C: packed record',
|
|
' A:byte;',
|
|
' case integer of',
|
|
' 5: (',
|
|
' B: record end;',
|
|
' );',
|
|
' 6: (',
|
|
' X:byte;',
|
|
' case integer of',
|
|
' 8: (',
|
|
' );',
|
|
' 9: (',
|
|
' );',
|
|
' );',
|
|
' end;',
|
|
' );',
|
|
' end;',
|
|
' );',
|
|
' 2: (',
|
|
' );',
|
|
' end;',
|
|
'',
|
|
'var',
|
|
''
|
|
]);
|
|
|
|
EnableFolds(AFolds);
|
|
|
|
CheckTokensForLine(' TFoo = record', 2, [tkSpace, tkIdentifier, tkSpace, TK_Equal, tkSpace, tkKey]);
|
|
CheckTokensForLine(' A:byte;', 3, [tkSpace, tkIdentifier, TK_Colon, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine(' case integer of', 4, [tkSpace, tkKey, tkSpace, tkIdentifier, tkSpace, tkKey]);
|
|
CheckTokensForLine(' 1: (', 5, [tkSpace, tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, TK_Bracket]);
|
|
CheckTokensForLine(' B: record', 6, [tkSpace, tkIdentifier, TK_Colon, tkSpace, tkKey]);
|
|
CheckTokensForLine(' case integer of', 7, [tkSpace, tkKey, tkSpace, tkIdentifier, tkSpace, tkKey]);
|
|
CheckTokensForLine(' 3: (', 8, [tkSpace, tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, TK_Bracket]);
|
|
CheckTokensForLine(' );', 9, [tkSpace, TK_Bracket, TK_Semi]);
|
|
CheckTokensForLine(' 4: (', 10, [tkSpace, tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, TK_Bracket]);
|
|
CheckTokensForLine(' C: packed record', 11, [tkSpace, tkIdentifier, TK_Colon, tkSpace, tkKey, tkSpace, tkKey]);
|
|
CheckTokensForLine(' A:byte;', 12, [tkSpace, tkIdentifier, TK_Colon, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine(' case integer of', 13, [tkSpace, tkKey, tkSpace, tkIdentifier, tkSpace, tkKey]);
|
|
CheckTokensForLine(' 5: (', 14, [tkSpace, tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, TK_Bracket]);
|
|
CheckTokensForLine(' B: record end;', 15, [tkSpace, tkIdentifier, TK_Colon, tkSpace, tkKey, tkSpace, tkKey, TK_Semi]);
|
|
CheckTokensForLine(' );', 16, [tkSpace, TK_Bracket, TK_Semi]);
|
|
CheckTokensForLine(' 6: (', 17, [tkSpace, tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, TK_Bracket]);
|
|
CheckTokensForLine(' X:byte;', 18, [tkSpace, tkIdentifier, TK_Colon, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine(' case integer of',19, [tkSpace, tkKey, tkSpace, tkIdentifier, tkSpace, tkKey]);
|
|
CheckTokensForLine(' 8: (', 20, [tkSpace, tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, TK_Bracket]);
|
|
CheckTokensForLine(' );', 21, [tkSpace, TK_Bracket, TK_Semi]);
|
|
CheckTokensForLine(' 9: (', 22, [tkSpace, tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, TK_Bracket]);
|
|
CheckTokensForLine(' );', 23, [tkSpace, TK_Bracket, TK_Semi]);
|
|
CheckTokensForLine(' );', 24, [tkSpace, TK_Bracket, TK_Semi]);
|
|
CheckTokensForLine(' end;', 25, [tkSpace, tkKey, TK_Semi]);
|
|
CheckTokensForLine(' );', 26, [tkSpace, TK_Bracket, TK_Semi]);
|
|
CheckTokensForLine(' end;', 27, [tkSpace, tkKey, TK_Semi]);
|
|
CheckTokensForLine(' );', 28, [tkSpace, TK_Bracket, TK_Semi]);
|
|
CheckTokensForLine(' 2: (', 29, [tkSpace, tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, TK_Bracket]);
|
|
CheckTokensForLine(' );', 30, [tkSpace, TK_Bracket, TK_Semi]);
|
|
CheckTokensForLine(' end;', 31, [tkSpace, tkKey, TK_Semi]);
|
|
|
|
|
|
if cfbtVarBlock in AFolds then
|
|
AssertEquals('Fold-Len type (1) ', 31, PasHighLighter.FoldLineLength(1, 0));
|
|
if cfbtRecord in AFolds then
|
|
AssertEquals('Fold-Len record (2) ', 29, PasHighLighter.FoldLineLength(2, 0));
|
|
if cfbtRecordCase in AFolds then begin
|
|
AssertEquals('Fold-Len case (4) ', 27, PasHighLighter.FoldLineLength( 4, 0));
|
|
AssertEquals('Fold-Len case (7) ', 20, PasHighLighter.FoldLineLength( 7, 0));
|
|
AssertEquals('Fold-Len case (13) ', 12, PasHighLighter.FoldLineLength(13, 0));
|
|
AssertEquals('Fold-Len case (19) ', 5, PasHighLighter.FoldLineLength(19, 0)); // closed by ")" of surrounding case-section
|
|
end;
|
|
if cfbtRecordCaseSection in AFolds then begin
|
|
AssertEquals('Fold-Len section (5) ', 23, PasHighLighter.FoldLineLength( 5, 0));
|
|
AssertEquals('Fold-Len section ( 8) ', 1, PasHighLighter.FoldLineLength( 8, 0));
|
|
AssertEquals('Fold-Len section (10) ', 16, PasHighLighter.FoldLineLength(10, 0));
|
|
AssertEquals('Fold-Len section (14) ', 2, PasHighLighter.FoldLineLength(14, 0));
|
|
AssertEquals('Fold-Len section (17) ', 7, PasHighLighter.FoldLineLength(17, 0));
|
|
AssertEquals('Fold-Len section (20) ', 1, PasHighLighter.FoldLineLength(20, 0));
|
|
AssertEquals('Fold-Len section (22) ', 1, PasHighLighter.FoldLineLength(22, 0));
|
|
AssertEquals('Fold-Len section (29) ', 1, PasHighLighter.FoldLineLength(29, 0));
|
|
end;
|
|
|
|
|
|
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestContextForStatic;
|
|
var
|
|
AFolds: TPascalCodeFoldBlockTypes;
|
|
i: Integer;
|
|
begin
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'Unit A; interface',
|
|
'type',
|
|
'static=class end;',
|
|
'TFoo=class(static)',
|
|
' Ffoo,static: static; static;',
|
|
' static: static; static;', // static as var-name can be first in list, IF previous was static modifier
|
|
' function static(static:static): static; static;',
|
|
' property static[static:static]: static read static write static;',
|
|
'public',
|
|
' Ffoo,static: static; static;',
|
|
' static: static; static;', // static as var-name can be first in list, IF previous was static modifier
|
|
' function static(static:static): static; static;',
|
|
' property static[static:static]: static read static write static;',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
for i := 0 to $08-1 do begin
|
|
AFolds := [cfbtBeginEnd..cfbtNone];
|
|
if (i and $01) = 0 then AFolds := AFolds - [cfbtProgram, cfbtUnit];
|
|
if (i and $02) = 0 then AFolds := AFolds - [cfbtUnitSection];
|
|
if (i and $04) = 0 then AFolds := AFolds - [cfbtClass, cfbtRecord];
|
|
EnableFolds(AFolds);
|
|
|
|
CheckTokensForLine('static = class', 2,
|
|
[tkIdentifier, tkSymbol, tkKey, tkSpace, tkKey, tkSymbol]);
|
|
CheckTokensForLine('Tfoo=class(static)', 3,
|
|
[tkIdentifier, tkSymbol, tkKey,tkSymbol, tkIdentifier, tkSymbol]);
|
|
CheckTokensForLine('fields', 4,
|
|
[tkSpace, tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkModifier, tkSymbol]);
|
|
CheckTokensForLine('fields 2', 5,
|
|
[tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkModifier, tkSymbol]);
|
|
CheckTokensForLine('function', 6,
|
|
[tkSpace, tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkIdentifier, tkSymbol, tkIdentifier, tkSymbol,
|
|
tkSymbol, tkSpace, tkIdentifier, tkSymbol, // : #32 static ;
|
|
tkSpace, tkModifier, tkSymbol // #32 static ;
|
|
]);
|
|
CheckTokensForLine('property', 7,
|
|
[tkSpace, tkKey, tkSpace, tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkIdentifier, tkSymbol,
|
|
tkSymbol, tkSpace, tkIdentifier, // : #32 static
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // #32 read static
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // #32 write static
|
|
tkSymbol // ;
|
|
]);
|
|
CheckTokensForLine('pup fields', 9,
|
|
[tkSpace, tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkModifier, tkSymbol]);
|
|
CheckTokensForLine('pup fields 2', 10,
|
|
[tkSpace, tkIdentifier, tkSymbol, tkSpace, tkIdentifier, tkSymbol, tkSpace, tkModifier, tkSymbol]);
|
|
CheckTokensForLine('pup function', 11,
|
|
[tkSpace, tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkIdentifier, tkSymbol, tkIdentifier, tkSymbol,
|
|
tkSymbol, tkSpace, tkIdentifier, tkSymbol, // : #32 static ;
|
|
tkSpace, tkModifier, tkSymbol // #32 static ;
|
|
]);
|
|
CheckTokensForLine('pup property', 12,
|
|
[tkSpace, tkKey, tkSpace, tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkIdentifier, tkSymbol,
|
|
tkSymbol, tkSpace, tkIdentifier, // : #32 static
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // #32 read static
|
|
tkSpace, tkKey, tkSpace, tkIdentifier, // #32 write static
|
|
tkSymbol // ;
|
|
]);
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestCaseLabel;
|
|
begin
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'program a; begin', // 0
|
|
'case b of',
|
|
'1: foo;', // 2
|
|
'bar: bar;',
|
|
'else foo;',
|
|
'end;',
|
|
'case b of',
|
|
'''123'': bar;', // 7
|
|
'bar: bar;',
|
|
'otherwise foo;',
|
|
'end;',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
PasHighLighter.CaseLabelAttriMatchesElseOtherwise := True;
|
|
CheckTokensForLine('1: foo;', 2, [tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('bar: bar;', 3, [tkIdentifier+FCaseLabelAttri, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('else foo;', 4, [tkKey+FCaseLabelAttri, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('end;', 5, [tkKey, TK_Semi]);
|
|
|
|
CheckTokensForLine('''123'': foo;', 7, [tkString+FCaseLabelAttri, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('bar: bar;', 8, [tkIdentifier+FCaseLabelAttri, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('else foo;', 9, [tkKey+FCaseLabelAttri, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('end;', 10, [tkKey, TK_Semi]);
|
|
|
|
|
|
PasHighLighter.CaseLabelAttriMatchesElseOtherwise := False;
|
|
CheckTokensForLine('1: foo;', 2, [tkNumber+FCaseLabelAttri, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('bar: bar;', 3, [tkIdentifier+FCaseLabelAttri, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('else foo;', 4, [tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('end;', 5, [tkKey, TK_Semi]);
|
|
|
|
CheckTokensForLine('''123'': foo;', 7, [tkString+FCaseLabelAttri, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('bar: bar;', 8, [tkIdentifier+FCaseLabelAttri, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('else foo;', 9, [tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('end;', 10, [tkKey, TK_Semi]);
|
|
|
|
|
|
FCaseLabelAttri.Clear;
|
|
FCaseLabelAttri := nil;
|
|
PasHighLighter.CaseLabelAttriMatchesElseOtherwise := True;
|
|
CheckTokensForLine('1: foo;', 2, [tkNumber, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('bar: bar;', 3, [tkIdentifier, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('else foo;', 4, [tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('end;', 5, [tkKey, TK_Semi]);
|
|
|
|
CheckTokensForLine('''123'': foo;', 7, [tkString, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('bar: bar;', 8, [tkIdentifier, TK_Colon, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('else foo;', 9, [tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
CheckTokensForLine('end;', 10, [tkKey, TK_Semi]);
|
|
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestModifierAttributesForProcedure;
|
|
var
|
|
ProcName, ProcParam, ProcType, ProcVal, ProcRes: TSynHighlighterAttributesModifier;
|
|
begin
|
|
FKeepAllModifierAttribs := True;
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'Unit A; interface', // 0
|
|
'function Foo: integer;',
|
|
'function Foo: string;',
|
|
'function Foo(var a:byte;b, b2:string;c:array of boolean): integer;',
|
|
'function Foo(d:word=2-x;e:boolean=(1=y*2);f:qword=default(qword); g:MySet=[a1..a2]): integer;',
|
|
'procedure Foo(a:byte;', //5
|
|
'b, b2:word);',
|
|
'', // 7
|
|
'procedure name; external &name name name;', // external const_NAME keyword_NAME const_NAME
|
|
'procedure name; external foo name name;', // external const_FOO keyword_NAME const_NAME
|
|
'procedure name; external name name;', // external keyword_NAME const_NAME
|
|
''
|
|
]);
|
|
|
|
ProcName := PasHighLighter.ProcedureHeaderName;
|
|
ProcParam := PasHighLighter.ProcedureHeaderParamAttr;
|
|
ProcType := PasHighLighter.ProcedureHeaderTypeAttr;
|
|
ProcVal := PasHighLighter.ProcedureHeaderValueAttr;
|
|
ProcRes := PasHighLighter.ProcedureHeaderResultAttr;
|
|
|
|
PasHighLighter.DeclaredTypeAttributeMode := tamIdentifierOnly;
|
|
PasHighLighter.DeclaredValueAttributeMode := tamIdentifierOnly;
|
|
PasHighLighter.DeclaredValueAttributeMachesStringNum := False;
|
|
|
|
CheckTokensForLine('2: function Foo: integer', 1,
|
|
[tkKey, tkSpace, tkIdentifier+ProcName, TK_Colon, tkSpace,
|
|
tkIdentifier+ProcRes, TK_Semi]);
|
|
|
|
CheckTokensForLine('3: function Foo: string', 2,
|
|
[tkKey, tkSpace, tkIdentifier+ProcName, TK_Colon, tkSpace,
|
|
tkKey, TK_Semi]);
|
|
|
|
CheckTokensForLine('4: function Foo(var a:byte;b, b2:string;c:array of boolean): integer;', 3,
|
|
[tkKey, tkSpace, tkIdentifier+ProcName, TK_Bracket,
|
|
tkKey, tkSpace, tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Comma, tkSpace, tkIdentifier+ProcParam, TK_Colon, tkKey, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkKey, tkSpace, tkKey, tkSpace, tkIdentifier+ProcType,
|
|
TK_Bracket, TK_Colon, tkSpace,
|
|
tkIdentifier+ProcRes, TK_Semi]);
|
|
|
|
CheckTokensForLine('4: function Foo(d:word=2-x;e:boolean=(1=y*2);f:qword=default(qword); g:MySet=[a1..a2]): integer;', 4,
|
|
[tkKey, tkSpace, tkIdentifier+ProcName, TK_Bracket,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType,
|
|
TK_Equal, tkNumber, tkSymbol, tkIdentifier+ProcVal, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType,
|
|
TK_Equal, TK_Bracket, tkNumber, tkSymbol, tkIdentifier+ProcVal, tkSymbol, tkNumber, TK_Bracket, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType,
|
|
TK_Equal, tkIdentifier+ProcVal, TK_Bracket, tkIdentifier+ProcVal, TK_Bracket, TK_Semi,
|
|
tkSpace,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType,
|
|
TK_Equal, TK_Bracket, tkIdentifier+ProcVal, tkSymbol, tkIdentifier+ProcVal, TK_Bracket,
|
|
TK_Bracket, TK_Colon, tkSpace,
|
|
tkIdentifier+ProcRes, TK_Semi]);
|
|
|
|
CheckTokensForLine('6: procedure Foo(a:byte;', 5,
|
|
[tkKey, tkSpace, tkIdentifier+ProcName, TK_Bracket,
|
|
tkIdentifier+ProcParam, TK_Semi]);
|
|
CheckTokensForLine('7: b, b2:word);', 6,
|
|
[tkIdentifier+ProcParam, TK_Comma, tkSpace, tkIdentifier+ProcParam, TK_Colon,
|
|
tkIdentifier+ProcType, TK_Bracket, TK_Semi]);
|
|
|
|
|
|
CheckTokensForLine('procedure name; external name name name;', 8,
|
|
[tkKey, tkSpace, tkIdentifier+ProcName, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkIdentifier, tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
//PropName.Clear;
|
|
//PasHighLighter.DeclaredTypeAttributeMode := tamIdentifierOnly;
|
|
//PasHighLighter.DeclaredValueAttributeMode := tamIdentifierOnly;
|
|
//PasHighLighter.DeclaredValueAttributeMachesStringNum := False;
|
|
|
|
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestModifierAttributesForProperty;
|
|
var
|
|
PropName, ProcParam, ProcType, ProcRes: TSynHighlighterAttributesModifier;
|
|
begin
|
|
FKeepAllModifierAttribs := True;
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'Unit A; interface', // 0
|
|
'property Foo: integer read Foo;',
|
|
'property Foo[a:byte;b:string;c:unit2.word]: unit2.integer read Foo;',
|
|
''
|
|
]);
|
|
|
|
PropName := PasHighLighter.PropertyNameAttr;
|
|
ProcParam := PasHighLighter.ProcedureHeaderParamAttr;
|
|
ProcType := PasHighLighter.ProcedureHeaderTypeAttr;
|
|
ProcRes := PasHighLighter.ProcedureHeaderResultAttr;
|
|
|
|
PasHighLighter.DeclaredTypeAttributeMode := tamIdentifierOnly;
|
|
PasHighLighter.DeclaredValueAttributeMode := tamIdentifierOnly;
|
|
PasHighLighter.DeclaredValueAttributeMachesStringNum := False;
|
|
|
|
CheckTokensForLine('1: unit a: interface;', 0,
|
|
[tkKey, tkSpace, tkIdentifier, TK_Semi, tkSpace, tkKey]);
|
|
|
|
CheckTokensForLine('2:property Foo: integer read Foo;', 1,
|
|
[tkKey, tkSpace, tkIdentifier+PropName, TK_Colon, tkSpace,
|
|
tkIdentifier+ProcRes, tkSpace,
|
|
tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
CheckTokensForLine('3:property Foo[a:byte;b:string;c:unit2.word]: unit2.integer read Foo;', 2,
|
|
[tkKey, tkSpace, tkIdentifier+PropName, TK_Bracket,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkKey, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Dot, tkIdentifier+ProcType,
|
|
TK_Bracket, TK_Colon, tkSpace,
|
|
tkIdentifier+ProcRes, TK_Dot, tkIdentifier+ProcRes, tkSpace,
|
|
tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
PasHighLighter.DeclaredTypeAttributeMode := tamPredefinedNames;
|
|
CheckTokensForLine('3:property Foo[a:byte;b;string;c:unit2.word]: unit2.integer read Foo;', 2,
|
|
[tkKey, tkSpace, tkIdentifier+PropName, TK_Bracket,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkKey+ProcType, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Dot, tkIdentifier+ProcType,
|
|
TK_Bracket, TK_Colon, tkSpace,
|
|
tkIdentifier+ProcRes, TK_Dot, tkIdentifier+ProcRes, tkSpace,
|
|
tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
PasHighLighter.DeclaredTypeAttributeMode := tamKeywordsAndSymbols;
|
|
CheckTokensForLine('3:property Foo[a:byte;b;string;c:unit2.word]: unit2.integer read Foo;', 2,
|
|
[tkKey, tkSpace, tkIdentifier+PropName, TK_Bracket,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkKey+ProcType, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Dot+ProcType, tkIdentifier+ProcType,
|
|
TK_Bracket, TK_Colon, tkSpace,
|
|
tkIdentifier+ProcRes, TK_Dot+ProcRes, tkIdentifier+ProcRes, tkSpace+ProcRes{for space....},
|
|
tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
|
|
|
|
PropName.Clear;
|
|
PasHighLighter.DeclaredTypeAttributeMode := tamIdentifierOnly;
|
|
PasHighLighter.DeclaredValueAttributeMode := tamIdentifierOnly;
|
|
PasHighLighter.DeclaredValueAttributeMachesStringNum := False;
|
|
|
|
CheckTokensForLine('2:property Foo: integer read Foo;', 1,
|
|
[tkKey, tkSpace, tkIdentifier, TK_Colon, tkSpace,
|
|
tkIdentifier+ProcRes, tkSpace,
|
|
tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
CheckTokensForLine('3:property Foo[a:byte;b;string;c:unit2.word]: unit2.integer read Foo;', 2,
|
|
[tkKey, tkSpace, tkIdentifier, TK_Bracket,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkKey, TK_Semi,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Dot, tkIdentifier+ProcType,
|
|
TK_Bracket, TK_Colon, tkSpace,
|
|
tkIdentifier+ProcRes, TK_Dot, tkIdentifier+ProcRes, tkSpace,
|
|
tkKey, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestModifierAttributesForVarConstType;
|
|
var
|
|
DeclVarName, DeclTypeName, DeclType, DeclVal, ProcName,
|
|
ProcParam, ProcType, ProcVal, ProcRes: TSynHighlighterAttributesModifier;
|
|
i: Integer;
|
|
begin
|
|
FKeepAllModifierAttribs := True;
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'Unit A; interface', // 0
|
|
'var',
|
|
'Foo: word deprecated;', //2
|
|
'Foo: word = val deprecated;',
|
|
'type',
|
|
'Foo= word deprecated;',
|
|
'const', // 6
|
|
'x:function (a:word; b:byte): integer = nil;', // 7
|
|
'type',
|
|
'x=function (): integer deprecated;', //9
|
|
'x=function (a:word): integer deprecated;',
|
|
'x=function (a:word=b): integer deprecated;',
|
|
'x=function (a:word; b:byte): integer deprecated;',
|
|
'var',
|
|
'a:record', // 14
|
|
'b:byte;',
|
|
'c:array of word;',
|
|
'end;',
|
|
'', // 18
|
|
'name: name; external name name;', // external keyword_NAME const_NAME
|
|
'name: name; external foo name name;', // external foo keyword_NAME const_NAME
|
|
''
|
|
]);
|
|
|
|
|
|
DeclVarName := PasHighLighter.DeclarationVarConstNameAttr;
|
|
DeclTypeName := PasHighLighter.DeclarationTypeNameAttr;
|
|
DeclType := PasHighLighter.DeclarationTypeAttr;
|
|
DeclVal := PasHighLighter.DeclarationValueAttr;
|
|
|
|
ProcName := PasHighLighter.ProcedureHeaderName;
|
|
ProcParam := PasHighLighter.ProcedureHeaderParamAttr;
|
|
ProcType := PasHighLighter.ProcedureHeaderTypeAttr;
|
|
ProcVal := PasHighLighter.ProcedureHeaderValueAttr;
|
|
ProcRes := PasHighLighter.ProcedureHeaderResultAttr;
|
|
|
|
PasHighLighter.DeclaredTypeAttributeMode := tamKeywords;
|
|
PasHighLighter.DeclaredValueAttributeMode := tamKeywords;
|
|
// inside the function, use the proc-attr
|
|
CheckTokensForLine('8:x:function (a:word; b:byte): integer = nil;', 7,
|
|
[tkIdentifier+DeclVarName, TK_Colon, tkKey+DeclType, tkSpace, TK_Bracket,
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Semi, tkSpace, // a:word
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, // b:byte
|
|
TK_Bracket, TK_Colon, tkSpace, // ):
|
|
tkIdentifier+ProcRes, tkSpace, // integer
|
|
TK_Equal, tkSpace, tkKey+DeclVal, TK_Semi
|
|
]);
|
|
//type
|
|
CheckTokensForLine('10:x=function (a:word): integer deprecated;', 9,
|
|
[tkIdentifier+DeclTypeName, TK_Colon, tkKey+DeclType, tkSpace, TK_Bracket, // x=function (
|
|
TK_Bracket, TK_Colon, tkSpace, // ):
|
|
tkIdentifier+ProcRes, tkSpace, // integer
|
|
tkModifier, TK_Semi // deprecated
|
|
]);
|
|
CheckTokensForLine('11:x=function (a:word): integer deprecated;', 10,
|
|
[tkIdentifier+DeclTypeName, TK_Colon, tkKey+DeclType, tkSpace, TK_Bracket, // x=function (
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, // a:word
|
|
TK_Bracket, TK_Colon, tkSpace, // ):
|
|
tkIdentifier+ProcRes, tkSpace, // integer
|
|
tkModifier, TK_Semi // deprecated
|
|
]);
|
|
CheckTokensForLine('12:x=function (a:word=b): integer deprecated;', 11,
|
|
[tkIdentifier+DeclTypeName, TK_Colon, tkKey+DeclType, tkSpace, TK_Bracket, // x=function (
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, // a:word
|
|
TK_Equal, tkIdentifier+ProcVal, // =b
|
|
TK_Bracket, TK_Colon, tkSpace, // ):
|
|
tkIdentifier+ProcRes, tkSpace, // integer
|
|
tkModifier, TK_Semi // deprecated
|
|
]);
|
|
CheckTokensForLine('13:x=function (a:word; b:byte): integer deprecated;', 12,
|
|
[tkIdentifier+DeclTypeName, TK_Colon, tkKey+DeclType, tkSpace, TK_Bracket, // x=function (
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Semi, tkSpace, // a:word
|
|
tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, // b:byte
|
|
TK_Bracket, TK_Colon, tkSpace, // ):
|
|
tkIdentifier+ProcRes, tkSpace, // integer
|
|
tkModifier, TK_Semi // deprecated
|
|
]);
|
|
|
|
// inside the record, use decl-attr according to record
|
|
// TODO: record and end are not DeclType, because cfbtVarConstTypeExt is missing
|
|
//CheckTokensForLine('15: a:record', 14,
|
|
// [tkIdentifier+DeclVarName, TK_Colon,tkKey+DeclType]);
|
|
CheckTokensForLine('16: b:byte', 15,
|
|
[tkIdentifier+DeclVarName, TK_Colon,tkIdentifier+DeclType]);
|
|
CheckTokensForLine('17: c:array of word', 16,
|
|
[tkIdentifier+DeclVarName, TK_Colon,tkKey+DeclType, tkSpace,
|
|
tkKey+DeclType, tkSpace, tkIdentifier+DeclType, TK_Semi]);
|
|
//CheckTokensForLine('18: end', 17,
|
|
// [tkKey+DeclType, TK_Semi]);
|
|
|
|
|
|
CheckTokensForLine('name: name; external name name;', 19,
|
|
[tkIdentifier+DeclVarName, TK_Colon, tkSpace, tkIdentifier+DeclType, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
CheckTokensForLine('name: name; external foo name name;', 20,
|
|
[tkIdentifier+DeclVarName, TK_Colon, tkSpace, tkIdentifier+DeclType, TK_Semi, tkSpace,
|
|
tkModifier, tkSpace, tkIdentifier, tkSpace, tkModifier, tkSpace, tkIdentifier, TK_Semi]);
|
|
|
|
|
|
for i := 0 to 1 do begin
|
|
case i of
|
|
0: begin
|
|
PasHighLighter.DeclaredTypeAttributeMode := tamIdentifierOnly;
|
|
PasHighLighter.DeclaredValueAttributeMode := tamIdentifierOnly;
|
|
PasHighLighter.DeclaredValueAttributeMachesStringNum := False;
|
|
end;
|
|
1: begin
|
|
PasHighLighter.DeclaredTypeAttributeMode := tamKeywords;
|
|
PasHighLighter.DeclaredValueAttributeMode := tamKeywords;
|
|
PasHighLighter.DeclaredValueAttributeMachesStringNum := True;
|
|
end;
|
|
end;
|
|
|
|
CheckTokensForLine('3: Foo: word; deprecated;', 2,
|
|
[tkIdentifier+DeclVarName, TK_Colon, tkSpace, tkIdentifier+DeclType,
|
|
tkSpace, tkModifier, TK_Semi]);
|
|
|
|
CheckTokensForLine('4: Foo: word = val; deprecated;', 3,
|
|
[tkIdentifier+DeclVarName, TK_Colon, tkSpace, tkIdentifier+DeclType,
|
|
tkSpace, TK_Equal, tkSpace, tkIdentifier+DeclVal,
|
|
tkSpace, tkModifier, TK_Semi]);
|
|
|
|
CheckTokensForLine('6: Foo= word; deprecated;', 5,
|
|
[tkIdentifier+DeclTypeName, TK_Equal, tkSpace, tkIdentifier+DeclType,
|
|
tkSpace, tkModifier, TK_Semi]);
|
|
|
|
end;
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestModifierAttributesWithAnonProcedure;
|
|
var
|
|
DeclVarName, DeclTypeName, DeclType, DeclVal, ProcName,
|
|
ProcParam, ProcType, ProcVal, ProcRes: TSynHighlighterAttributesModifier;
|
|
x: String;
|
|
begin
|
|
x := 'end; procedure test; begin'; // in case the anon function closed the named function
|
|
FKeepAllModifierAttribs := True;
|
|
ReCreateEdit;
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]);
|
|
SetLines
|
|
(['program foo;{$mode objfpc}{$modeswitch anonymousfunctions}{$modeswitch functionreferences}',
|
|
'type t= reference to procedure;',
|
|
'var a: t; procedure test;',
|
|
'begin',
|
|
'a :=(', // 4
|
|
'procedure',
|
|
'var',
|
|
' n: word;', // 7
|
|
'begin',
|
|
' n := 1;',
|
|
'end',
|
|
');',
|
|
x+'',
|
|
'a :=', // 13
|
|
'procedure',
|
|
'var',
|
|
' n: word;', // 16
|
|
'begin',
|
|
' n := 1;',
|
|
'end;',
|
|
'',
|
|
x+ '',
|
|
'a :=(', // 22
|
|
'procedure(var t:byte; var t2:byte)',
|
|
'var',
|
|
' n: word;', // 25
|
|
'begin',
|
|
' n := 1;',
|
|
'end',
|
|
');',
|
|
'',
|
|
x+'',
|
|
'a :=', // 32
|
|
'procedure(var t:byte; var t2:byte)',
|
|
'var',
|
|
' n: word;', // 35
|
|
'begin',
|
|
' n := 1;',
|
|
'end;',
|
|
'',
|
|
'',
|
|
x+ '',
|
|
'a :=(', // 42
|
|
'procedure',
|
|
'(var t:byte; var t2:byte)',
|
|
'var',
|
|
' n: word;', // 46
|
|
'begin',
|
|
' n := 1;',
|
|
'end',
|
|
');',
|
|
x+'',
|
|
'a :=', // 52
|
|
'procedure',
|
|
'(var t:byte; var t2:byte)',
|
|
'var',
|
|
' n: word;', // 56
|
|
'begin',
|
|
' n := 1;',
|
|
'end;',
|
|
'',
|
|
x+ '',
|
|
|
|
'end.'
|
|
]);
|
|
|
|
// NOT extra attribs...
|
|
AssertEquals('Len procedure', 5, PasHighLighter.FoldLineLength(5,0));
|
|
AssertEquals('Len var', 1, PasHighLighter.FoldLineLength(6,0));
|
|
AssertEquals('Len begin', 2, PasHighLighter.FoldLineLength(8,0));
|
|
AssertEquals('Len procedure', 5, PasHighLighter.FoldLineLength(14,0));
|
|
AssertEquals('Len var', 1, PasHighLighter.FoldLineLength(15,0));
|
|
AssertEquals('Len begin', 2, PasHighLighter.FoldLineLength(17,0));
|
|
AssertEquals('Len procedure', 5, PasHighLighter.FoldLineLength(23,0));
|
|
AssertEquals('Len var', 1, PasHighLighter.FoldLineLength(24,0));
|
|
AssertEquals('Len begin', 2, PasHighLighter.FoldLineLength(26,0));
|
|
AssertEquals('Len procedure', 5, PasHighLighter.FoldLineLength(33,0));
|
|
AssertEquals('Len var', 1, PasHighLighter.FoldLineLength(34,0));
|
|
AssertEquals('Len begin', 2, PasHighLighter.FoldLineLength(36,0));
|
|
AssertEquals('Len procedure', 6, PasHighLighter.FoldLineLength(43,0));
|
|
AssertEquals('Len var', 1, PasHighLighter.FoldLineLength(45,0));
|
|
AssertEquals('Len begin', 2, PasHighLighter.FoldLineLength(47,0));
|
|
AssertEquals('Len procedure', 6, PasHighLighter.FoldLineLength(53,0));
|
|
AssertEquals('Len var', 1, PasHighLighter.FoldLineLength(55,0));
|
|
AssertEquals('Len begin', 2, PasHighLighter.FoldLineLength(57,0));
|
|
|
|
DeclVarName := PasHighLighter.DeclarationVarConstNameAttr;
|
|
DeclTypeName := PasHighLighter.DeclarationTypeNameAttr;
|
|
DeclType := PasHighLighter.DeclarationTypeAttr;
|
|
DeclVal := PasHighLighter.DeclarationValueAttr;
|
|
|
|
ProcName := PasHighLighter.ProcedureHeaderName;
|
|
ProcParam := PasHighLighter.ProcedureHeaderParamAttr;
|
|
ProcType := PasHighLighter.ProcedureHeaderTypeAttr;
|
|
ProcVal := PasHighLighter.ProcedureHeaderValueAttr;
|
|
ProcRes := PasHighLighter.ProcedureHeaderResultAttr;
|
|
|
|
CheckTokensForLine('procedure', 5, [tkKey ]);
|
|
CheckTokensForLine('var', 6, [tkKey ]);
|
|
CheckTokensForLine(' n: word;', 7,
|
|
[tkSpace, tkIdentifier+DeclVarName, TK_Colon, tkSpace, tkIdentifier+DeclType, TK_Semi ]);
|
|
|
|
CheckTokensForLine('procedure', 14, [tkKey ]);
|
|
CheckTokensForLine('var', 15, [tkKey ]);
|
|
CheckTokensForLine(' n: word;', 16,
|
|
[tkSpace, tkIdentifier+DeclVarName, TK_Colon, tkSpace, tkIdentifier+DeclType, TK_Semi ]);
|
|
|
|
CheckTokensForLine('procedure(var t:byte; var t2:byte)', 23,
|
|
[tkKey, TK_Bracket,
|
|
tkKey, tkSpace, tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Semi, tkSpace,
|
|
tkKey, tkSpace, tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Bracket
|
|
]);
|
|
CheckTokensForLine('var', 24, [tkKey ]);
|
|
CheckTokensForLine(' n: word;', 25,
|
|
[tkSpace, tkIdentifier+DeclVarName, TK_Colon, tkSpace, tkIdentifier+DeclType, TK_Semi ]);
|
|
|
|
CheckTokensForLine('procedure(var t:byte; var t2:byte)', 33,
|
|
[tkKey, TK_Bracket,
|
|
tkKey, tkSpace, tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Semi, tkSpace,
|
|
tkKey, tkSpace, tkIdentifier+ProcParam, TK_Colon, tkIdentifier+ProcType, TK_Bracket
|
|
]);
|
|
CheckTokensForLine('var', 34, [tkKey ]);
|
|
CheckTokensForLine(' n: word;', 35,
|
|
[tkSpace, tkIdentifier+DeclVarName, TK_Colon, tkSpace, tkIdentifier+DeclType, TK_Semi ]);
|
|
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestModifierAttributesForLabel;
|
|
var
|
|
GotoLbl: TSynHighlighterAttributes;
|
|
begin
|
|
FKeepAllModifierAttribs := True;
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'Unit A; interface', // 0
|
|
'label lbl1,',
|
|
'lbl2',
|
|
', lbl3 ;',
|
|
'procedure foo;', // 4
|
|
'label lbl4;',
|
|
'begin',
|
|
'lbl1:', // 7
|
|
' lbl2:',
|
|
'foo:=1;',
|
|
'lbl3:',
|
|
'if true then', // 11
|
|
'lbl3:',
|
|
'case x of',
|
|
'abc: ;',
|
|
'def: lbla: lblb: {} lblc: i:=1;', // 15
|
|
'xyz: ;',
|
|
'else ;',
|
|
'; lbl: ;', // 18
|
|
'end;',
|
|
'end;',
|
|
'repeat', // 21
|
|
'lbl:',
|
|
'until false;',
|
|
''
|
|
]);
|
|
|
|
GotoLbl := PasHighLighter.GotoLabelAttr;
|
|
|
|
CheckTokensForLine('2: label lbl1,', 1,
|
|
[tkKey, tkSpace, tkIdentifier+GotoLbl, TK_Comma]);
|
|
|
|
CheckTokensForLine('3: lbl2', 2,
|
|
[tkIdentifier+GotoLbl]);
|
|
|
|
CheckTokensForLine('4: , lbl3 ;', 3,
|
|
[TK_Comma, tkSpace, tkIdentifier+GotoLbl, tkSpace, TK_Semi]);
|
|
|
|
CheckTokensForLine('6: label lbl4;', 5,
|
|
[tkKey, tkSpace, tkIdentifier+GotoLbl, TK_Semi]);
|
|
|
|
CheckTokensForLine('8: lbl1:', 7,
|
|
[tkIdentifier+GotoLbl, TK_Colon]);
|
|
|
|
CheckTokensForLine('9: lbl2:', 8,
|
|
[tkSpace, tkIdentifier+GotoLbl, TK_Colon]);
|
|
|
|
CheckTokensForLine('10: foo:=1;', 9,
|
|
[tkIdentifier, tkSymbol, tkNumber, TK_Semi]);
|
|
|
|
CheckTokensForLine('11: lbl3:', 10,
|
|
[tkIdentifier+GotoLbl, TK_Colon]);
|
|
|
|
CheckTokensForLine('13: lbl3:', 12,
|
|
[tkIdentifier+GotoLbl, TK_Colon]);
|
|
|
|
CheckTokensForLine('15: abc: ;', 14,
|
|
[tkIdentifier+FCaseLabelAttri, TK_Colon, tkSpace, TK_Semi]);
|
|
|
|
CheckTokensForLine('16: def: lbla: lblb: {} lblc: i:=1;', 15,
|
|
[tkIdentifier+FCaseLabelAttri, TK_Colon, tkSpace,
|
|
tkIdentifier+GotoLbl, TK_Colon, tkSpace,
|
|
tkIdentifier+GotoLbl, TK_Colon, tkSpace, tkComment, tkSpace,
|
|
tkIdentifier+GotoLbl, TK_Colon, tkSpace,
|
|
tkIdentifier, tkSymbol, tkNumber, TK_Semi]);
|
|
|
|
CheckTokensForLine('17: xyz: ;', 16,
|
|
[tkIdentifier+FCaseLabelAttri, TK_Colon, tkSpace, TK_Semi]);
|
|
|
|
CheckTokensForLine('18: else ;', 17,
|
|
[tkKey+FCaseLabelAttri, tkSpace, TK_Semi]);
|
|
|
|
CheckTokensForLine('19: ; lbl: ;', 18,
|
|
[TK_Semi, tkSpace, tkIdentifier+GotoLbl, TK_Colon, tkSpace, TK_Semi]);
|
|
|
|
CheckTokensForLine('23: lbl:', 22,
|
|
[tkIdentifier+GotoLbl, TK_Colon]);
|
|
|
|
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestCaretAsString;
|
|
begin
|
|
ReCreateEdit;
|
|
SetLines
|
|
([ 'Unit A; interface', // 0
|
|
'var',
|
|
'a:char=^o;',
|
|
'a:somestring=^o^c;',
|
|
'b:^char=nil;',
|
|
'c:record A:char; B:^char; end=(a:^c;b:nil);', // 5
|
|
'type',
|
|
'c=^char;', // 7
|
|
'c=type ^char;', // 8
|
|
'f=procedure(a:char=^c);',
|
|
'const',
|
|
'f:procedure(a:char=^c) =nil;',
|
|
'd:record A:char; B:^char; end=(a:^c;b:nil);', //12
|
|
'implementation',
|
|
'function x(f:^char=^k^c):^v;', // actually the compiler does not allow ^ as pointer for result
|
|
'var',
|
|
'a:char=^o;', // 16
|
|
'b:^char=nil;', // 17
|
|
'type', // 18
|
|
'c=^char;',
|
|
'begin',
|
|
'i:=^f;',
|
|
'x:=GetTypeData(PropInfo^.PropType{$IFNDEF FPC}^{$ENDIF});', // 18
|
|
'c:=p^;',
|
|
'c:=p ^;',
|
|
'c:=p(**)^;',
|
|
'c:=p{} ^;', // 26
|
|
'i:=f(1)^;', // 27
|
|
'i:=f[1]^;',
|
|
'i:=f^^;',
|
|
'c:=p^+^i''e''^a#13^x;',
|
|
'c:=x=^a and ^a=k and(^a^a=z);',
|
|
'end;',
|
|
''
|
|
]);
|
|
|
|
CheckTokensForLine('a:char=^o;', 2,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkString, tkSymbol]);
|
|
CheckTokensForLine('a:char=^o^c;', 3,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkString, tkString, tkSymbol]);
|
|
CheckTokensForLine('b:^char=nil;', 4,
|
|
[tkIdentifier, tkSymbol, tkSymbol, tkIdentifier, tkSymbol, tkKey, tkSymbol]);
|
|
CheckTokensForLine('c:record A:char; B:^char; end=(a:^c;b:nil);', 5,
|
|
[tkIdentifier, tkSymbol, tkKey, tkSpace,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkIdentifier, TK_Colon, tkSymbol, tkIdentifier, TK_Semi, tkSpace, tkKey,
|
|
TK_Equal, TK_Bracket,
|
|
tkIdentifier, TK_Colon, tkString, TK_Semi, tkIdentifier, TK_Colon, tkKey,
|
|
TK_Bracket, TK_Semi
|
|
]);
|
|
|
|
CheckTokensForLine('c=^char;', 7,
|
|
[tkIdentifier, tkSymbol, tkSymbol, tkIdentifier, tkSymbol]);
|
|
CheckTokensForLine('c=type ^char;', 8,
|
|
[tkIdentifier, tkSymbol, tkKey, tkSpace, tkSymbol, tkIdentifier, tkSymbol]);
|
|
CheckTokensForLine('f=procedure(a:char=^c);', 9,
|
|
[tkIdentifier, tkSymbol, tkKey, TK_Bracket,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkString, TK_Bracket, TK_Semi]);
|
|
|
|
CheckTokensForLine('f:procedure(a:char=^c) =nil;', 11,
|
|
[tkIdentifier, tkSymbol, tkKey, TK_Bracket,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Equal, tkString, TK_Bracket, tkSpace,
|
|
TK_Equal, tkKey, TK_Semi]);
|
|
|
|
CheckTokensForLine('CONST d:record A:char; B:^char; end=(a:^c;b:nil);', 12,
|
|
[tkIdentifier, tkSymbol, tkKey, tkSpace,
|
|
tkIdentifier, TK_Colon, tkIdentifier, TK_Semi, tkSpace,
|
|
tkIdentifier, TK_Colon, tkSymbol, tkIdentifier, TK_Semi, tkSpace, tkKey,
|
|
TK_Equal, TK_Bracket,
|
|
tkIdentifier, TK_Colon, tkString, TK_Semi, tkIdentifier, TK_Colon, tkKey,
|
|
TK_Bracket, TK_Semi
|
|
]);
|
|
|
|
CheckTokensForLine('function x(f:^char=^k):^v;', 14,
|
|
[tkKey, tkSpace, tkIdentifier + FAttrProcName, tkSymbol, tkIdentifier, // function x(f
|
|
tkSymbol, tkSymbol, tkIdentifier, tkSymbol, tkString, tkString, // :^char=^k
|
|
tkSymbol, tkSymbol, tkSymbol, tkIdentifier, tkSymbol]); // ):^v;
|
|
CheckTokensForLine('LOCAL a:char=^o;', 16,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkString, tkSymbol]);
|
|
CheckTokensForLine('LOCAL b:^char=nil;', 17,
|
|
[tkIdentifier, tkSymbol, tkSymbol, tkIdentifier, tkSymbol, tkKey, tkSymbol]);
|
|
CheckTokensForLine('LOCAL c=^char;', 19,
|
|
[tkIdentifier, tkSymbol, tkSymbol, tkIdentifier, tkSymbol]);
|
|
CheckTokensForLine('i:=^f', 21,
|
|
[tkIdentifier, tkSymbol, tkString, tkSymbol]);
|
|
|
|
CheckTokensForLine('x:=GetTypeData(PropInfo^.PropType{$IFNDEF FPC}^{$ENDIF});', 22,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, // x:=GetTypeData(
|
|
tkIdentifier, tkSymbol, tkSymbol, tkIdentifier, // PropInfo^.PropType
|
|
tkDirective, tkSymbol, tkDirective, tkSymbol, tkSymbol]); // {$IFNDEF FPC}^{$ENDIF});
|
|
|
|
CheckTokensForLine('c:=p^;', 23,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkSymbol]);
|
|
CheckTokensForLine('c:=p ^;', 24,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSpace, tkSymbol, tkSymbol]);
|
|
CheckTokensForLine('c:=p(**)^;', 25,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkComment, tkSymbol, tkSymbol]);
|
|
CheckTokensForLine('c:=p{} ^;', 26,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkComment, tkSpace, tkSymbol, tkSymbol]);
|
|
|
|
CheckTokensForLine('c:=p(1)^;', 27,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkNumber, tkSymbol, tkSymbol]);
|
|
CheckTokensForLine('c:=p[1]^;', 28,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkNumber, tkSymbol, tkSymbol]);
|
|
CheckTokensForLine('c:=p^^;', 29,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkSymbol, tkSymbol]);
|
|
|
|
CheckTokensForLine('c:=p^+^i''e''^a#13^x;', 30,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkSymbol, // c:=p^+
|
|
tkString, tkString, tkString, tkString, tkString, tkSymbol // ^i'e'^a#13^x;
|
|
]);
|
|
CheckTokensForLine('c:=x=^a and ^a=k and(^a^a=z);', 31,
|
|
[tkIdentifier, tkSymbol, tkIdentifier, tkSymbol, tkString, tkSpace, // c:=x=^a
|
|
tkKey, tkSpace, tkString, tkSymbol, tkIdentifier, tkSpace, // and ^a=k
|
|
tkKey, tkSymbol, tkString, tkString, tkSymbol, tkIdentifier, // and(^a^a=z
|
|
tkSymbol, tkSymbol // );'
|
|
]);
|
|
|
|
end;
|
|
|
|
procedure TTestHighlighterPas.TestFoldNodeInfo;
|
|
Procedure CheckNode(ALine: TLineIdx; AFilter: TSynFoldActions; AFoldGroup: Integer;
|
|
AColumn: integer;
|
|
AAllColIndex, LogXStart, LogXEnd, FoldLvlStart, FoldLvlEnd, NestLvlStart, NestLvlEnd: Integer;
|
|
FoldType, FoldTypeCompatible: TPascalCodeFoldBlockType; FoldGroup: Integer;
|
|
FoldAction: TSynFoldActions);
|
|
var
|
|
nd: TSynFoldNodeInfo;
|
|
l: TLazSynFoldNodeInfoList;
|
|
begin
|
|
l := PasHighLighter.FoldNodeInfo[ALine];
|
|
|
|
// use NodeInfoEx
|
|
nd := PasHighLighter.FoldNodeInfo[ALine].NodeInfoEx(AColumn, AFilter, AFoldGroup);
|
|
CheckPasFoldNodeInfo('', nd, ALine, AColumn, AAllColIndex, LogXStart, LogXEnd, FoldLvlStart,
|
|
FoldLvlEnd, NestLvlStart, NestLvlEnd, FoldType, FoldTypeCompatible,
|
|
FoldGroup, FoldAction);
|
|
|
|
// use filter
|
|
l.ClearFilter;
|
|
l.ActionFilter := AFilter;
|
|
l.GroupFilter := AFoldGroup;
|
|
nd := PasHighLighter.FoldNodeInfo[ALine].Item[AColumn];
|
|
CheckPasFoldNodeInfo('', nd, ALine, AColumn, AAllColIndex, LogXStart, LogXEnd, FoldLvlStart,
|
|
FoldLvlEnd, NestLvlStart, NestLvlEnd, FoldType, FoldTypeCompatible,
|
|
FoldGroup, FoldAction);
|
|
end;
|
|
Procedure CheckNode(ALine: TLineIdx; AFilter: TSynFoldActions; AFoldGroup: Integer;
|
|
AColumn: integer;
|
|
LogXStart, LogXEnd, FoldLvlStart, FoldLvlEnd, NestLvlStart, NestLvlEnd: Integer;
|
|
FoldType, FoldTypeCompatible: TPascalCodeFoldBlockType; FoldGroup: Integer;
|
|
FoldAction: TSynFoldActions);
|
|
begin
|
|
CheckNode(ALine, AFilter, AFoldGroup, AColumn, -1, LogXStart, LogXEnd,
|
|
FoldLvlStart, FoldLvlEnd, NestLvlStart, NestLvlEnd, FoldType, FoldTypeCompatible,
|
|
FoldGroup, FoldAction);
|
|
end;
|
|
begin
|
|
ReCreateEdit;
|
|
PushBaseName('');
|
|
// // +(\d+) +(\d+) +(\d+) +(\d+) +(\d+) +(\d+) +(\d+) +(\d+) +(\d+) +(\d+) +(\S+)
|
|
// CheckNode( 0, [], 0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, [$11]);
|
|
|
|
//Line, [filter], group, Idx, LogXStart End FldLvlStart End NestLvlStart End FldType FldTypeCompat FldGroup [FldAction]
|
|
|
|
{%region TEXT 1}
|
|
|
|
{%region TEXT 1 -- [cfbtBeginEnd..cfbtNone], []}
|
|
PopPushBaseName('Text 1 -- [cfbtBeginEnd..cfbtNone], [], 0');
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], []);
|
|
//DebugFoldInfo([]);
|
|
|
|
CheckFoldInfoCounts('', [], 0, [1, 1, 1, 1, 1, 3, 0, 1, 2, 1, 2, 2]);
|
|
|
|
// Line 0: program foo; # pasminlvl=0 endlvl=1
|
|
CheckNode( 0, [], 0, 0, 0, 0, 7, 0, 1, 0, 1,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: procedure a; # pasminlvl=1 endlvl=2
|
|
CheckNode( 1, [], 0, 0, 0, 0, 9, 1, 2, 1, 2,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 2: {$ifdef a} # pasminlvl=2 endlvl=2
|
|
CheckNode( 2, [], 0, 0, 0, 1, 7, 0, 1, 0, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 3: begin # pasminlvl=2 endlvl=3
|
|
CheckNode( 3, [], 0, 0, 0, 0, 5, 2, 3, 2, 3,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 4: {$endif} # pasminlvl=3 endlvl=3
|
|
CheckNode( 4, [], 0, 0, 0, 1, 7, 1, 0, 1, 0,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 5: {$ifdef b} if a then begin {$endif} zz# pasminlvl=3 endlvl=4
|
|
CheckNode( 5, [], 0, 0, 0, 3, 9, 0, 1, 0, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaMarkup,sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode( 5, [], 0, 1, 1, 23, 28, 3, 4, 3, 4,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
CheckNode( 5, [], 0, 2, 2, 30, 36, 1, 0, 1, 0,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaMarkup,sfaOneLineClose, sfaSingleLine]);
|
|
// Line 6: writeln() # pasminlvl=4 endlvl=4
|
|
// Line 7: end; # pasminlvl=3 endlvl=3
|
|
CheckNode( 7, [], 0, 0, 0, 2, 5, 4, 3, 4, 3,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 8: end; # pasminlvl=1 endlvl=1
|
|
CheckNode( 8, [], 0, 0, 0, 0, 3, 3, 2, 3, 2,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 8, [], 0, 1, 1, 0, 3, 2, 1, 2, 1,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 9: begin # pasminlvl=1 endlvl=2
|
|
CheckNode( 9, [], 0, 0, 0, 0, 5, 1, 2, 1, 2,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 10: end. # pasminlvl=0 endlvl=0
|
|
CheckNode(10, [], 0, 0, 0, 0, 3, 2, 1, 2, 1,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode(10, [], 0, 1, 1, 0, 3, 1, 0, 1, 0,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 11: // # pasminlvl=0 endlvl=0
|
|
CheckNode(11, [], 0, 0, 0, 0, 2, 0, 1, 0, 1,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode(11, [], 0, 1, 1, 2, 2, 1, 0, 1, 0,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaOneLineClose,sfaLastLineClose, sfaSingleLine]);
|
|
{%endregion TEXT 1 -- [cfbtBeginEnd..cfbtNone], []}
|
|
|
|
{%region TEXT 1 -- [cfbtBeginEnd..cfbtNone], [] grp=1}
|
|
PopPushBaseName('Text 1 -- [cfbtBeginEnd..cfbtNone], [], grp=1');
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], []);
|
|
//DebugFoldInfo([],1);
|
|
|
|
CheckFoldInfoCounts('', [], 1, [1, 1, 0, 1, 0, 1, 0, 1, 2, 1, 2, 2]);
|
|
|
|
// Line 0: program foo; # pasminlvl=0 endlvl=1
|
|
CheckNode( 0, [], 1, 0, 0, 0, 7, 0, 1, 0, 1,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: procedure a; # pasminlvl=1 endlvl=2
|
|
CheckNode( 1, [], 1, 0, 0, 0, 9, 1, 2, 1, 2,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 2: {$ifdef a} # pasminlvl=2 endlvl=2
|
|
// Line 3: begin # pasminlvl=2 endlvl=3
|
|
CheckNode( 3, [], 1, 0, 0, 0, 5, 2, 3, 2, 3,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 4: {$endif} # pasminlvl=3 endlvl=3
|
|
// Line 5: {$ifdef b} if a then begin {$endif} # pasminlvl=3 endlvl=4
|
|
CheckNode( 5, [], 1, 0, 1, 23, 28, 3, 4, 3, 4,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 6: writeln() # pasminlvl=4 endlvl=4
|
|
// Line 7: end; # pasminlvl=3 endlvl=3
|
|
CheckNode( 7, [], 1, 0, 0, 2, 5, 4, 3, 4, 3,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 8: end; # pasminlvl=1 endlvl=1
|
|
CheckNode( 8, [], 1, 0, 0, 0, 3, 3, 2, 3, 2,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 8, [], 1, 1, 1, 0, 3, 2, 1, 2, 1,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 9: begin # pasminlvl=1 endlvl=2
|
|
CheckNode( 9, [], 1, 0, 0, 0, 5, 1, 2, 1, 2,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 10: end. # pasminlvl=0 endlvl=0
|
|
CheckNode(10, [], 1, 0, 0, 0, 3, 2, 1, 2, 1,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode(10, [], 1, 1, 1, 0, 3, 1, 0, 1, 0,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 11: // # pasminlvl=0 endlvl=0
|
|
CheckNode(11, [], 1, 0, 0, 0, 2, 0, 1, 0, 1,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode(11, [], 1, 1, 1, 2, 2, 1, 0, 1, 0,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaOneLineClose,sfaLastLineClose, sfaSingleLine]);
|
|
{%endregion TEXT 1 -- [cfbtBeginEnd..cfbtNone], [] grp=1}
|
|
|
|
{%region TEXT 1 -- [cfbtBeginEnd,cfbtIfDef], [] grp=1}
|
|
PopPushBaseName('Text 1 -- [cfbtBeginEnd,cfbtIfDef], [], grp=4');
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd,cfbtIfDef]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], []);
|
|
//DebugFoldInfo([],4);
|
|
|
|
CheckFoldInfoCounts('', [], 1, [1, 1, 0, 1, 0, 1, 0, 1, 2, 1, 2, 2]);
|
|
|
|
// Line 0: program foo; # pasminlvl=0 endlvl=0
|
|
CheckNode( 0, [], 1, 0, 0, 7, 0, 0, 0, 1,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold, sfaMultiLine]); // program
|
|
// Line 1: procedure a; # pasminlvl=0 endlvl=0
|
|
CheckNode( 1, [], 1, 0, 0, 9, 1, 1, 1, 2,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold, sfaMultiLine]); // procedure
|
|
// Line 2: {$ifdef a} # pasminlvl=0 endlvl=0
|
|
// Line 3: begin # pasminlvl=0 endlvl=0
|
|
CheckNode( 3, [], 1, 0, 0, 5, 2, 2, 2, 3,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold, sfaMultiLine]); // begin
|
|
// Line 4: {$endif} # pasminlvl=0 endlvl=0
|
|
// Line 5: {$ifdef b} if a then begin {$endif} # pasminlvl=0 endlvl=1
|
|
CheckNode( 5, [], 1, 0, 23, 28, 0, 1, 3, 4,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]); // begin
|
|
// Line 6: writeln() # pasminlvl=1 endlvl=1
|
|
// Line 7: end; # pasminlvl=0 endlvl=0
|
|
CheckNode( 7, [], 1, 0, 2, 5, 1, 0, 4, 3,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]); // end
|
|
// Line 8: end; # pasminlvl=0 endlvl=0
|
|
CheckNode( 8, [], 1, 0, 0, 3, 3, 3, 3, 2,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold, sfaMultiLine]); // end;
|
|
CheckNode( 8, [], 1, 1, 0, 3, 2, 2, 2, 1,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold, sfaMultiLine]); // end;
|
|
// Line 9: begin # pasminlvl=0 endlvl=1
|
|
CheckNode( 9, [], 1, 0, 0, 5, 0, 1, 1, 2,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]); // begin
|
|
// Line 10: end. # pasminlvl=0 endlvl=0
|
|
CheckNode(10, [], 1, 0, 0, 3, 1, 0, 2, 1,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]); // end.
|
|
CheckNode(10, [], 1, 1, 0, 3, 1, 1, 1, 0,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold, sfaMultiLine]); // end.
|
|
// Line 11: // # pasminlvl=0 endlvl=0
|
|
CheckNode(11, [], 1, 0, 0, 2, 0, 0, 0, 1,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold, sfaMultiLine]); // //
|
|
CheckNode(11, [], 1, 1, 2, 2, 1, 1, 1, 0,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaLastLineClose, sfaMultiLine]); // /
|
|
{%endregion TEXT 1 -- [cfbtBeginEnd..cfbtNone], [] grp=4}
|
|
|
|
{%region TEXT 1 -- [cfbtBeginEnd..cfbtNone], [sfaFold, sfaMultiLine]}
|
|
PopPushBaseName('Text 1 -- [cfbtBeginEnd..cfbtNone], [sfaFold, sfaMultiLine], 0');
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], []);
|
|
//DebugFoldInfo([sfaFold, sfaMultiLine]);
|
|
|
|
CheckFoldInfoCounts('', [sfaFold, sfaMultiLine], 0, [1, 1, 1, 1, 1, 1, 0, 1, 2, 1, 2, 0]);
|
|
|
|
// Line 0: program foo; # pasminlvl=0 endlvl=1
|
|
CheckNode( 0, [sfafold, sfaMultiLine], 0, 0, 0, 7, 0, 1, 0, 1,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: procedure a; # pasminlvl=1 endlvl=2
|
|
CheckNode( 1, [sfafold, sfaMultiLine], 0, 0, 0, 9, 1, 2, 1, 2,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 2: {$ifdef a} # pasminlvl=2 endlvl=2
|
|
CheckNode( 2, [sfafold, sfaMultiLine], 0, 0, 1, 7, 0, 1, 0, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 3: begin # pasminlvl=2 endlvl=3
|
|
CheckNode( 3, [sfafold, sfaMultiLine], 0, 0, 0, 5, 2, 3, 2, 3,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 4: {$endif} # pasminlvl=3 endlvl=3
|
|
CheckNode( 4, [sfafold, sfaMultiLine], 0, 0, 1, 7, 1, 0, 1, 0,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold,sfaFoldFold,sfaMultiLine]);
|
|
// Line 5: {$ifdef b} if a then begin {$endif} # pasminlvl=3 endlvl=4
|
|
CheckNode( 5, [sfafold, sfaMultiLine], 0, 0, 23, 28, 3, 4, 3, 4,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 6: writeln() # pasminlvl=4 endlvl=4
|
|
// Line 7: end; # pasminlvl=3 endlvl=3
|
|
CheckNode( 7, [sfafold, sfaMultiLine], 0, 0, 2, 5, 4, 3, 4, 3,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 8: end; # pasminlvl=1 endlvl=1
|
|
CheckNode( 8, [sfafold, sfaMultiLine], 0, 0, 0, 3, 3, 2, 3, 2,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 8, [sfafold, sfaMultiLine], 0, 1, 0, 3, 2, 1, 2, 1,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 9: begin # pasminlvl=1 endlvl=2
|
|
CheckNode( 9, [sfafold, sfaMultiLine], 0, 0, 0, 5, 1, 2, 1, 2,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 10: end. # pasminlvl=0 endlvl=0
|
|
CheckNode(10, [sfafold, sfaMultiLine], 0, 0, 0, 3, 2, 1, 2, 1,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode(10, [sfafold, sfaMultiLine], 0, 1, 0, 3, 1, 0, 1, 0,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 11: // # pasminlvl=0 endlvl=0
|
|
|
|
{%endregion TEXT 1 -- [cfbtBeginEnd..cfbtNone], [sfaFold, sfaMultiLine]}
|
|
|
|
{%region TEXT 1 -- [cfbtBeginEnd..cfbtNone], [sfaMarkup, sfaMultiLine]}
|
|
PopPushBaseName('Text 1 -- [cfbtBeginEnd..cfbtNone]-cfbtIfDef, [sfaMarkup, sfaMultiLine], 0');
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtIfDef]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], []);
|
|
//DebugFoldInfo([sfaMarkup, sfaMultiLine]);
|
|
|
|
CheckFoldInfoCounts('', [sfaMarkup, sfaMultiLine], 0, [1, 1, 0, 1, 0, 1, 0, 1, 2, 1, 2, 0]);
|
|
// Line 0: program foo; # pasminlvl=0 endlvl=1
|
|
CheckNode( 0, [sfamarkup, sfaMultiLine], 0, 0, 0, 7, 0, 1, 0, 1,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: procedure a; # pasminlvl=1 endlvl=2
|
|
CheckNode( 1, [sfamarkup, sfaMultiLine], 0, 0, 0, 9, 1, 2, 1, 2,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 2: {$ifdef a} # pasminlvl=2 endlvl=2
|
|
// TODO add check for IFDEF
|
|
// Line 3: begin # pasminlvl=2 endlvl=3
|
|
CheckNode( 3, [sfamarkup, sfaMultiLine], 0, 0, 0, 5, 2, 3, 2, 3,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 4: {$endif} # pasminlvl=3 endlvl=3
|
|
// Line 5: {$ifdef b} if a then begin {$endif} # pasminlvl=3 endlvl=4
|
|
// TODO add chek for IFDEF
|
|
CheckNode( 5, [sfamarkup, sfaMultiLine], 0, 0, 23, 28, 3, 4, 3, 4,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 6: writeln() # pasminlvl=4 endlvl=4
|
|
// Line 7: end; # pasminlvl=3 endlvl=3
|
|
CheckNode( 7, [sfamarkup, sfaMultiLine], 0, 0, 2, 5, 4, 3, 4, 3,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 8: end; # pasminlvl=1 endlvl=1
|
|
CheckNode( 8, [sfamarkup, sfaMultiLine], 0, 0, 0, 3, 3, 2, 3, 2,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 8, [sfamarkup, sfaMultiLine], 0, 1, 0, 3, 2, 1, 2, 1,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 9: begin # pasminlvl=1 endlvl=2
|
|
CheckNode( 9, [sfamarkup, sfaMultiLine], 0, 0, 0, 5, 1, 2, 1, 2,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 10: end. # pasminlvl=0 endlvl=0
|
|
CheckNode(10, [sfamarkup, sfaMultiLine], 0, 0, 0, 3, 2, 1, 2, 1,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode(10, [sfamarkup, sfaMultiLine], 0, 1, 0, 3, 1, 0, 1, 0,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 11: // # pasminlvl=0 endlvl=0
|
|
|
|
{%endregion TEXT 1 -- [cfbtBeginEnd..cfbtNone], [sfaMarkup, sfaMultiLine]}
|
|
|
|
{%region TEXT 1 -- [cfbtBeginEnd..cfbtNone], [sfaMarkup, sfaMultiLine]}
|
|
PopPushBaseName('Text 1 -- [cfbtBeginEnd..cfbtNone], [sfaMarkup, sfaMultiLine], cfbtIfDef 0');
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], [], [cfbtIfDef]);
|
|
//DebugFoldInfo([sfaMarkup, sfaMultiLine]);
|
|
|
|
CheckFoldInfoCounts('', [sfaMarkup, sfaMultiLine], 0, [1, 1, 1, 1, 1, 3, 0, 1, 2, 1, 2, 0]);
|
|
// Line 0: program foo; # pasminlvl=0 endlvl=1
|
|
CheckNode( 0, [sfamarkup, sfaMultiLine], 0, 0, 0, 7, 0, 1, 0, 1,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: procedure a; # pasminlvl=1 endlvl=2
|
|
CheckNode( 1, [sfamarkup, sfaMultiLine], 0, 0, 0, 9, 1, 2, 1, 2,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 2: {$ifdef a} # pasminlvl=2 endlvl=2
|
|
// TODO add chek for IFDEF
|
|
// Line 3: begin # pasminlvl=2 endlvl=3
|
|
CheckNode( 3, [sfamarkup, sfaMultiLine], 0, 0, 0, 5, 2, 3, 2, 3,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 4: {$endif} # pasminlvl=3 endlvl=3
|
|
// Line 5: {$ifdef b} if a then begin {$endif} # pasminlvl=3 endlvl=4
|
|
// TODO add chek for IFDEF
|
|
CheckNode( 5, [sfamarkup, sfaMultiLine], 0, 1, 23, 28, 3, 4, 3, 4,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 6: writeln() # pasminlvl=4 endlvl=4
|
|
// Line 7: end; # pasminlvl=3 endlvl=3
|
|
CheckNode( 7, [sfamarkup, sfaMultiLine], 0, 0, 2, 5, 4, 3, 4, 3,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 8: end; # pasminlvl=1 endlvl=1
|
|
CheckNode( 8, [sfamarkup, sfaMultiLine], 0, 0, 0, 3, 3, 2, 3, 2,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 8, [sfamarkup, sfaMultiLine], 0, 1, 0, 3, 2, 1, 2, 1,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 9: begin # pasminlvl=1 endlvl=2
|
|
CheckNode( 9, [sfamarkup, sfaMultiLine], 0, 0, 0, 5, 1, 2, 1, 2,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 10: end. # pasminlvl=0 endlvl=0
|
|
CheckNode(10, [sfamarkup, sfaMultiLine], 0, 0, 0, 3, 2, 1, 2, 1,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode(10, [sfamarkup, sfaMultiLine], 0, 1, 0, 3, 1, 0, 1, 0,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 11: // # pasminlvl=0 endlvl=0
|
|
|
|
{%endregion TEXT 1 -- [cfbtBeginEnd..cfbtNone], [sfaMarkup, sfaMultiLine]}
|
|
|
|
{%region TEXT 1 -- [cfbtBeginEnd..cfbtNone]-[cfbtProcedure], [cfbtSlashComment]}
|
|
PopPushBaseName('Text 1 -- [cfbtBeginEnd..cfbtNone]-[cfbtProcedure], [cfbtSlashComment], 0');
|
|
SetLines(TestTextFoldInfo1);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtProcedure]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], [cfbtSlashComment]);
|
|
//DebugFoldInfo([]);
|
|
|
|
CheckFoldInfoCounts('', [], 0, [1, 1, 1, 1, 1, 3, 0, 1, 2, 1, 2, 2, 0]);
|
|
|
|
// Line 0: program foo; # pasminlvl=0 endlvl=1
|
|
CheckNode( 0, [], 0, 0, 0, 7, 0, 1, 0, 1,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: procedure a; # pasminlvl=1 endlvl=1
|
|
CheckNode( 1, [], 0, 0, 0, 9, 1, 1, 1, 2,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold, sfaMultiLine]);
|
|
// Line 2: {$ifdef a} # pasminlvl=1 endlvl=1
|
|
CheckNode( 2, [], 0, 0, 1, 7, 0, 1, 0, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 3: begin # pasminlvl=1 endlvl=2
|
|
CheckNode( 3, [], 0, 0, 0, 5, 1, 2, 2, 3,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 4: {$endif} # pasminlvl=2 endlvl=2
|
|
CheckNode( 4, [], 0, 0, 1, 7, 1, 0, 1, 0,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 5: {$ifdef b} if a then begin {$endif} # pasminlvl=2 endlvl=3
|
|
CheckNode( 5, [], 0, 0, 3, 9, 0, 1, 0, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaMarkup,sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode( 5, [], 0, 1, 23, 28, 2, 3, 3, 4,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
CheckNode( 5, [], 0, 2, 30, 36, 1, 0, 1, 0,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaMarkup,sfaOneLineClose, sfaSingleLine]);
|
|
// Line 6: writeln() # pasminlvl=3 endlvl=3
|
|
// Line 7: end; # pasminlvl=2 endlvl=2
|
|
CheckNode( 7, [], 0, 0, 2, 5, 3, 2, 4, 3,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 8: end; # pasminlvl=1 endlvl=1
|
|
CheckNode( 8, [], 0, 0, 0, 3, 2, 1, 3, 2,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 8, [], 0, 1, 0, 3, 2, 2, 2, 1,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold, sfaMultiLine]);
|
|
// Line 9: begin # pasminlvl=1 endlvl=2
|
|
CheckNode( 9, [], 0, 0, 0, 5, 1, 2, 1, 2,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 10: end. # pasminlvl=0 endlvl=0
|
|
CheckNode(10, [], 0, 0, 0, 3, 2, 1, 2, 1,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode(10, [], 0, 1, 0, 3, 1, 0, 1, 0,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 11: // # pasminlvl=0 endlvl=0
|
|
CheckNode(11, [], 0, 0, 0, 2, 0, 1, 0, 1,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaFold,sfaFoldHide,sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode(11, [], 0, 1, 2, 2, 1, 0, 1, 0,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaFold,sfaOneLineClose,sfaLastLineClose, sfaSingleLine]);
|
|
{%endregion TEXT 1 -- [cfbtBeginEnd..cfbtNone]-[cfbtProcedure], [cfbtSlashComment]}
|
|
|
|
{%endregion TEXT 1}
|
|
|
|
|
|
{%region TEXT 2}
|
|
|
|
{%region TEXT 2 -- [cfbtBeginEnd..cfbtNone], []}
|
|
PopPushBaseName('Text 2 -- [cfbtBeginEnd..cfbtNone], [], 0');
|
|
SetLines(TestTextFoldInfo2);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], []);
|
|
//DebugFoldInfo([]);
|
|
|
|
CheckFoldInfoCounts('', [], 0, [1, 1, 10, 2, 4, 5, 2, 3]);
|
|
|
|
// Line 0: program foo; # pasminlvl=0 endlvl=1
|
|
CheckNode( 0, [], 0, 0, 0, 7, 0, 1, 0, 1,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: procedure a; # pasminlvl=1 endlvl=2
|
|
CheckNode( 1, [], 0, 0, 0, 9, 1, 2, 1, 2,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 2: {$ifdef a} begin {$ifdef b} repeat a; {$endif} until b; {$ifdef c} try {$else} //x zz# pasminlvl=2 endlvl=4
|
|
CheckNode( 2, [], 0, 0, 1, 7, 0, 1, 0, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]); // {$IFDEF A}
|
|
CheckNode( 2, [], 0, 1, 11, 16, 2, 3, 2, 3,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]); // begin
|
|
CheckNode( 2, [], 0, 2, 18, 24, 1, 2, 1, 2,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaMarkup,sfaOneLineOpen, sfaSingleLine]); // {$IFDEF B}
|
|
CheckNode( 2, [], 0, 3, 28, 34, 3, 4, 3, 4,
|
|
cfbtRepeat, cfbtRepeat, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaMarkup,sfaOneLineOpen, sfaSingleLine]); // repeat a;
|
|
CheckNode( 2, [], 0, 4, 39, 45, 2, 1, 2, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaMarkup,sfaOneLineClose, sfaSingleLine]); // {$ENDIF}
|
|
CheckNode( 2, [], 0, 5, 47, 52, 4, 3, 4, 3,
|
|
cfbtRepeat, cfbtRepeat, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaMarkup,sfaOneLineClose, sfaSingleLine]); // until b;
|
|
CheckNode( 2, [], 0, 6, 57, 63, 1, 2, 1, 2,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaMarkup,sfaOneLineOpen, sfaSingleLine]); // {$IFDEF c}
|
|
CheckNode( 2, [], 0, 7, 67, 70, 3, 4, 3, 4,
|
|
cfbtTry, cfbtTry, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);// try
|
|
CheckNode( 2, [], 0, 8, 72, 77, 2, 1, 2, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaMarkup,sfaOneLineClose, sfaSingleLine, sfaCloseAndOpen]); // {$ELSE}
|
|
CheckNode( 2, [], 0, 9, 72, 77, 1, 2, 1, 2,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaMarkup,sfaOpen, sfaOpenFold,sfaFold,sfaFoldFold, sfaMultiLine, sfaCloseAndOpen]); // {$ELSE}
|
|
// Line 3: //foo # pasminlvl=4 endlvl=4
|
|
CheckNode( 3, [], 0, 0, 2, 4, 4, 5, 4, 5,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode( 3, [], 0, 1, 7, 7, 5, 4, 5, 4,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaOneLineClose, sfaCloseForNextLine, sfaSingleLine]);
|
|
// Line 4: finally repeat x; {$endif c} until y; # pasminlvl=4 endlvl=5
|
|
CheckNode( 4, [], 0, 0, 2, 9, 4, 5, 4, 5,
|
|
cfbtExcept, cfbtExcept, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
CheckNode( 4, [], 0, 1, 10, 16, 5, 6, 5, 6,
|
|
cfbtRepeat, cfbtRepeat, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaMarkup,sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode( 4, [], 0, 2, 21, 27, 2, 1, 2, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
CheckNode( 4, [], 0, 3, 31, 36, 6, 5, 6, 5,
|
|
cfbtRepeat, cfbtRepeat, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaMarkup,sfaOneLineClose, sfaSingleLine]);
|
|
// Line 5: repeat m; until n; end; {$endif a} // # pasminlvl=3 endlvl=3
|
|
CheckNode( 5, [], 0, 0, 2, 8, 5, 6, 5, 6,
|
|
cfbtRepeat, cfbtRepeat, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaMarkup,sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode( 5, [], 0, 1, 12, 17, 6, 5, 6, 5,
|
|
cfbtRepeat, cfbtRepeat, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaMarkup,sfaOneLineClose, sfaSingleLine]);
|
|
CheckNode( 5, [], 0, 2, 21, 24, 5, 4, 5, 4,
|
|
cfbtExcept, cfbtExcept, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 5, [], 0, 3, 21, 24, 4, 3, 4, 3,
|
|
cfbtTry, cfbtTry, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 5, [], 0, 4, 27, 33, 1, 0, 1, 0,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 6: end # pasminlvl=1 endlvl=1
|
|
CheckNode( 6, [], 0, 0, 0, 3, 3, 2, 3, 2,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 6, [], 0, 1, 0, 3, 2, 1, 2, 1,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 7: begin end. # pasminlvl=0 endlvl=0
|
|
CheckNode( 7, [], 0, 0, 0, 5, 1, 2, 1, 2,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaMarkup,sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode( 7, [], 0, 1, 6, 9, 2, 1, 2, 1,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaMarkup,sfaOneLineClose, sfaSingleLine]);
|
|
CheckNode( 7, [], 0, 2, 6, 9, 1, 0, 1, 0,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
{%endregion TEXT 2 -- [cfbtBeginEnd..cfbtNone], []}
|
|
|
|
{%region TEXT 2}
|
|
|
|
|
|
{%region TEXT 3}
|
|
|
|
{%region TEXT 3 -- [cfbtBeginEnd..cfbtNone], []}
|
|
PopPushBaseName('Text 3 -- [cfbtBeginEnd..cfbtNone], [], 0');
|
|
SetLines(TestTextFoldInfo3);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], []);
|
|
//DebugFoldInfo([]);
|
|
|
|
CheckFoldInfoCounts('', [], 0, [1, 1, 2, 1, 1, 1, 0, 3, 1, 3, 2]);
|
|
|
|
// Line 0: unit foo; # pasminlvl=0 endlvl=1
|
|
CheckNode( 0, [], 0, 0, 0, 4, 0, 1, 0, 1,
|
|
cfbtUnit, cfbtUnit, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: interface # pasminlvl=1 endlvl=2
|
|
CheckNode( 1, [], 0, 0, 0, 9, 1, 2, 1, 2,
|
|
cfbtUnitSection, cfbtUnitSection, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 2: type a=integer; # pasminlvl=2 endlvl=2
|
|
CheckNode( 2, [], 0, 0, 0, 4, 2, 3, 2, 3,
|
|
cfbtVarBlock, cfbtVarBlock, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode( 2, [], 0, 1, 15, 15, 3, 2, 3, 2,
|
|
cfbtVarBlock, cfbtVarBlock, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaOneLineClose, sfaCloseForNextLine, sfaSingleLine]);
|
|
// Line 3: var # pasminlvl=2 endlvl=3
|
|
CheckNode( 3, [], 0, 0, 0, 3, 2, 3, 2, 3,
|
|
cfbtVarBlock, cfbtVarBlock, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 4: b:integer # pasminlvl=2 endlvl=2
|
|
CheckNode( 4, [], 0, 0, 11, 11, 3, 2, 3, 2,
|
|
cfbtVarBlock, cfbtVarBlock, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaFold, sfaCloseForNextLine, sfaMultiLine]);
|
|
// Line 5: const # pasminlvl=2 endlvl=3
|
|
CheckNode( 5, [], 0, 0, 0, 5, 2, 3, 2, 3,
|
|
cfbtVarBlock, cfbtVarBlock, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 6: c = 1; # pasminlvl=3 endlvl=3
|
|
// Line 7: d = 2; {$ifdef a} # pasminlvl=1 endlvl=1
|
|
CheckNode( 7, [], 0, 0, 10, 16, 0, 1, 0, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
CheckNode( 7, [], 0, 1, 19, 19, 3, 2, 3, 2,
|
|
cfbtVarBlock, cfbtVarBlock, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaFold, sfaCloseForNextLine, sfaMultiLine]);
|
|
CheckNode( 7, [], 0, 2, 19, 19, 2, 1, 2, 1,
|
|
cfbtUnitSection, cfbtUnitSection, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaFold, sfaCloseForNextLine, sfaMultiLine]);
|
|
// Line 8: implementation # pasminlvl=1 endlvl=2
|
|
CheckNode( 8, [], 0, 0, 0, 14, 1, 2, 1, 2,
|
|
cfbtUnitSection, cfbtUnitSection, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 9: //, unit-section # pasminlvl=1 endlvl=1
|
|
CheckNode( 9, [], 0, 0, 0, 2, 2, 3, 2, 3,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode( 9, [], 0, 1, 2, 2, 3, 2, 3, 2,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaOneLineClose, sfaCloseForNextLine, sfaSingleLine]);
|
|
CheckNode( 9, [], 0, 2, 2, 2, 2, 1, 2, 1,
|
|
cfbtUnitSection, cfbtUnitSection, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaFold, sfaCloseForNextLine, sfaMultiLine]);
|
|
// Line 10: end. # pasminlvl=0 endlvl=0
|
|
CheckNode(10, [], 0, 0, 0, 3, 1, 0, 1, 0,
|
|
cfbtUnit, cfbtUnit, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaFold, sfaMultiLine]);
|
|
CheckNode(10, [], 0, 1, 4, 4, 1, 0, 1, 0,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold,sfaFoldFold,sfaLastLineClose, sfaMultiLine]);
|
|
{%endregion TEXT 3 -- [cfbtBeginEnd..cfbtNone], []}
|
|
|
|
{%region TEXT 3}
|
|
|
|
|
|
{%region TEXT 4}
|
|
|
|
{%region TEXT 4 -- [cfbtBeginEnd..cfbtNone], []}
|
|
PopPushBaseName('Text 4(1) -- [cfbtBeginEnd..cfbtNone], [], 0');
|
|
SetLines(TestTextFoldInfo4(1));
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], []);
|
|
//DebugFoldInfo([]);
|
|
|
|
CheckFoldInfoCounts('', [], 0, [1, 1,3, 1, 2, 1, 3]);
|
|
|
|
// Line 0: program p; # pasminlvl=0 endlvl=1
|
|
CheckNode( 0, [], 0, 0, 0, 7, 0, 1, 0, 1,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: procedure a; # pasminlvl=1 endlvl=2
|
|
CheckNode( 1, [], 0, 0, 0, 9, 1, 2, 1, 2,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 2: begin {$ifdef} if a then begin # pasminlvl=2 endlvl=4
|
|
CheckNode( 2, [], 0, 0, 0, 5, 2, 3, 2, 3,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
CheckNode( 2, [], 0, 1, 7, 13, 0, 1, 0, 1,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
CheckNode( 2, [], 0, 2, 25, 30, 3, 4, 3, 4,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 3: end; // 2 # pasminlvl=3 endlvl=3
|
|
CheckNode( 3, [], 0, 0, 2, 5, 4, 3, 4, 3,
|
|
cfbtBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 4: end; // 1 # pasminlvl=1 endlvl=1
|
|
CheckNode( 4, [], 0, 0, 0, 3, 3, 2, 3, 2,
|
|
cfbtTopBeginEnd, cfbtBeginEnd, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
CheckNode( 4, [], 0, 1, 0, 3, 2, 1, 2, 1,
|
|
cfbtProcedure, cfbtProcedure, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold, sfaMultiLine]);
|
|
// Line 5: {$endif} # pasminlvl=1 endlvl=1
|
|
CheckNode( 5, [], 0, 0, 1, 7, 1, 0, 1, 0,
|
|
cfbtIfDef, cfbtIfDef, FOLDGROUP_IFDEF,
|
|
[sfaClose, sfaCloseFold,sfaMarkup,sfaFold,sfaFoldFold, sfaMultiLine]);
|
|
// Line 6: // # pasminlvl=1 endlvl=0
|
|
CheckNode( 6, [], 0, 0, 0, 2, 1, 2, 1, 2,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode( 6, [], 0, 1, 2, 2, 2, 1, 2, 1,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaOneLineClose,sfaLastLineClose, sfaSingleLine]);
|
|
CheckNode( 6, [], 0, 2, 2, 2, 1, 0, 1, 0,
|
|
cfbtProgram, cfbtProgram, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaFold,sfaLastLineClose, sfaMultiLine]);
|
|
{%endregion TEXT 4 -- [cfbtBeginEnd..cfbtNone], []}
|
|
|
|
{%region TEXT 4}
|
|
|
|
{%region TEXT 5}
|
|
|
|
{%region TEXT 5 -- [cfbtBeginEnd..cfbtNone], []}
|
|
PopPushBaseName('Text 5 -- [cfbtBeginEnd..cfbtNone], [], 0');
|
|
SetLines(TestTextFoldInfo5);
|
|
EnableFolds([cfbtBeginEnd..cfbtNone]-[cfbtForDo,cfbtWhileDo,cfbtWithDo], []);
|
|
//DebugFoldInfo([]);
|
|
|
|
CheckFoldInfoCounts('', [], 0, [1, 1, 1, 1, 0, 1, 1, 0, 3, 1, 3, 1]);
|
|
|
|
// Line 0: unit foo;
|
|
CheckNode( 0, [], 0, 0, 0, 4, 0, 1, 0, 1,
|
|
cfbtUnit, cfbtUnit, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold, sfaFold, sfaFoldFold, sfaMultiLine]);
|
|
// Line 1: interface
|
|
CheckNode( 1, [], 0, 0, 0, 9, 1, 2, 1, 2,
|
|
cfbtUnitSection, cfbtUnitSection, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold, sfaFold, sfaFoldFold, sfaMultiLine]);
|
|
// Line 2: type
|
|
CheckNode( 2, [], 0, 0, 0, 4, 2, 3, 2, 3,
|
|
cfbtVarBlock, cfbtVarBlock, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaFold, sfaFoldFold, sfaMultiLine, sfaOpenFold]);
|
|
// Line 3: TFoo<T: class> = class(TBar<T>)
|
|
CheckNode( 3, [], 0, 0, 17, 22, 3, 4, 3, 4,
|
|
cfbtClass, cfbtClass, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaFold, sfaFoldFold, sfaMultiLine, sfaMarkup, sfaOpenFold]);
|
|
// Line 4: class procedure Proc;
|
|
CheckNode( 4, [], 0, -1, 0, 0, 4, 4, 4, 4,
|
|
cfbtNone, cfbtNone, FOLDGROUP_PASCAL,
|
|
[sfaInvalid]);
|
|
// Line 5: end.
|
|
CheckNode( 5, [], 0, 0, 0, 3, 4, 3, 4, 3,
|
|
cfbtClass, cfbtClass, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaFold, sfaMultiLine, sfaMarkup, sfaCloseFold]);
|
|
CheckNode( 6, [], 0, 0, 7, 13, 3, 4, 3, 4,
|
|
cfbtRecord, cfbtRecord, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaFold, sfaFoldFold, sfaMultiLine, sfaMarkup, sfaOpenFold]);
|
|
// Line 7: class procedure Proc;
|
|
CheckNode( 7, [], 0, -1, 0, 0, 4, 4, 4, 4,
|
|
cfbtNone, cfbtNone, FOLDGROUP_PASCAL,
|
|
[sfaInvalid]);
|
|
// Line 8: end.
|
|
CheckNode( 8, [], 0, 0, 0, 3, 4, 3, 4, 3,
|
|
cfbtRecord, cfbtRecord, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaFold, sfaMultiLine, sfaMarkup, sfaCloseFold]);
|
|
CheckNode( 8, [], 0, 1, 4, 4, 3, 2, 3, 2,
|
|
cfbtVarBlock, cfbtVarBlock, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaFold, sfaMultiLine, sfaCloseForNextLine, sfaCloseFold]);
|
|
CheckNode( 8, [], 0, 2, 4, 4, 2, 1, 2, 1,
|
|
cfbtUnitSection, cfbtUnitSection, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaFold, sfaMultiLine, sfaCloseForNextLine, sfaCloseFold]);
|
|
// Line 9: implementation
|
|
CheckNode( 9, [], 0, 0, 0, 14, 1, 2, 1, 2,
|
|
cfbtUnitSection, cfbtUnitSection, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOpenFold,sfaFold, sfaFoldFold, sfaMultiLine]);
|
|
// Line 10: //, unit-section
|
|
CheckNode(10, [], 0, 0, 0, 2, 2, 3, 2, 3,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaOpen, sfaOneLineOpen, sfaSingleLine]);
|
|
CheckNode(10, [], 0, 1, 2, 2, 3, 2, 3, 2,
|
|
cfbtSlashComment, cfbtSlashComment, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaOneLineClose, sfaCloseForNextLine, sfaSingleLine]);
|
|
CheckNode(10, [], 0, 2, 2, 2, 2, 1, 2, 1,
|
|
cfbtUnitSection, cfbtUnitSection, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaFold, sfaCloseForNextLine, sfaMultiLine]);
|
|
// Line 11: end.
|
|
CheckNode(11, [], 0, 0, 0, 3, 1, 0, 1, 0,
|
|
cfbtUnit, cfbtUnit, FOLDGROUP_PASCAL,
|
|
[sfaClose, sfaCloseFold,sfaFold, sfaMultiLine]);
|
|
{%endregion TEXT 5 -- [cfbtBeginEnd..cfbtNone], []}
|
|
|
|
{%region TEXT 5}
|
|
end;
|
|
|
|
initialization
|
|
|
|
RegisterTest(TTestHighlighterPas);
|
|
end.
|
|
|