1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
{(*}
(*------------------------------------------------------------------------------
Delphi Code formatter source code
The Original Code is AlignVars.pas, released April 2000.
The Initial Developer of the Original Code is Anthony Steele.
Portions created by Anthony Steele are Copyright (C) 1999-2008 Anthony Steele.
All Rights Reserved.
Contributor(s): Anthony Steele.
The contents of this file are subject to the Mozilla Public License Version 1.1
(the "License"). you may not use this file except in compliance with the License.
You may obtain a copy of the License at http://www.mozilla.org/NPL/
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied.
See the License for the specific language governing rights and limitations
under the License.
Alternatively, the contents of this file may be used under the terms of
the GNU General Public License Version 2 or later (the "GPL")
See http://www.gnu.org/licenses/gpl.html
------------------------------------------------------------------------------*)
{*)}
unit AlignVars;
{ AFS 12 Feb 2K
Align the RHS of var types
}
{$I JcfGlobal.inc}
interface
uses SourceToken, AlignBase;
type
TFoundTokenState = (eBefore, eOn, eAfter, eUnknown);
TAlignVars = class(TAlignBase)
protected
feFoundTokenState: TFoundTokenState;
function AlignedToken(const pt: TSourceToken): boolean; virtual;
{ TokenProcessor overrides }
function IsTokenInContext(const pt: TSourceToken): boolean; override;
{ AlignStatements overrides }
function TokenIsAligned(const pt: TSourceToken): boolean; override;
function TokenEndsStatement(const pt: TSourceToken): boolean; override;
procedure OnTokenRead(const pt: TSourceToken); override;
procedure ResetState; override;
public
constructor Create; override;
function IsIncludedInSettings: boolean; override;
end;
implementation
uses
{ local}Tokens, FormatFlags, JcfSettings,
ParseTreeNodeType,
TokenUtils, Nesting;
{ TAlignVars }
constructor TAlignVars.Create;
begin
inherited;
FormatFlags := FormatFlags + [eAlignVars];
feFoundTokenState := eUnknown;
end;
function TAlignVars.AlignedToken(const pt: TSourceToken): boolean;
const
NOT_ALIGNED: TTokenTypeSet = [ttWhiteSpace, ttReturn, ttComment, ttSemiColon, ttColon];
begin
Result := ( not (pt.TokenType in NOT_ALIGNED)) and
pt.HasParentNode(nVarSection) and pt.IsOnRightOf(nVarDecl, ttColon);
end;
procedure TAlignVars.OnTokenRead(const pt: TSourceToken);
begin
inherited;
{ when we get the colon, we are now *before* the target token
on the next on-whitespace token we are *on* it,
any token after that, we are *after* it
unknown status is there to match the very first token in the block }
if pt.TokenType = ttColon then
feFoundTokenState := eBefore
else if AlignedToken(pt) and
(feFoundTokenState in [eUnknown, eBefore]) then
feFoundTokenState := eOn
else if feFoundTokenState = eOn then
feFoundTokenState := eAfter
else if feFoundTokenState = eUnknown then
feFoundTokenState := eBefore;
end;
procedure TAlignVars.ResetState;
begin
inherited;
feFoundTokenState := eUnknown;
end;
function TAlignVars.TokenEndsStatement(const pt: TSourceToken): boolean;
begin
if pt = nil then
Result := True
{ only look at solid tokens }
else if (pt.TokenType in [ttReturn, ttWhiteSpace]) then
begin
// ended by a blank line
Result := IsBlankLineEnd(pt);
end
else
begin
Result := (pt.TokenType = ttSemiColon) or ( not pt.HasParentNode(nVarSection));
end;
end;
function TAlignVars.IsTokenInContext(const pt: TSourceToken): boolean;
begin
Result := (pt.HasParentNode(nVarSection)) and (RoundBracketLevel(pt) < 1) and
((not FormattingSettings.Align.InterfaceOnly) or (pt.HasParentNode(nInterfaceSection)));
end;
function TAlignVars.TokenIsAligned(const pt: TSourceToken): boolean;
begin
{ the local var feFoundTokenState is used to recognise the first token
in the type after the colon }
Result := (feFoundTokenState in [eOn, eUnknown]) and AlignedToken(pt);
if Result and (pt.Nestings.GetLevel(nlRecordType) > 0) then
Result := False;
if Result and (RoundBracketLevel(pt) > 0) then
Result := False;
end;
function TAlignVars.IsIncludedInSettings: boolean;
begin
Result := (not FormattingSettings.Obfuscate.Enabled) and FormattingSettings.Align.AlignVar;
end;
end.
|
