Fully automatic indentation: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		# Overview
2	2
3	3		Since 0.9.29 the lazarus source editor has a new algorithm for automatic indentation on pressing Enter or on pasting code from clipboard. This new algorithm works only for pascal and does not use static rules, but parses the sources to imitate the indentation. Most other editors use either a fixed set of rules or a set of options to configure the rules. This is semi automatic indentation. These options are either too simple or too complex. And the other editors only allow one set of rules, so editing sources with different policies is difficult.
4	4
5	5		Fully automatic indentation tries to guess the rules from the surrounding code. It does that by searching for similar code and copying the indent.
6	6
7	7		Because it works fully automatic there are only a few options. You can disable it, you can setup the search scope and you can provide an example code: [[IDE Window: Codetools Options\|Codetools Options: Indentation]]. You do not need to learn rules, just write pascal.
8	8
9	9		# How it works
10	10
11	11		## Indent on paste from clipboard
12	12
13	13		For example you have the code:
14	14
15	15		``` pascal
16	16		procedure TMainForm.Button1Click(Sender: TObject);
17	17		begin
18		-	\|
19	18		end;
20	19		```
21	20
22	21		You place the cursor at column 1 and paste the code
23	22
24	23		``` pascal
25	24		if Visible then
26	25		begin
27	26		end;
28	27		```
29	28
30	29		Note that the code on the clipboard is already indented by 4.
31	30
32	31		The indenter first scans the code, finds out, that the insertion position is in a begin..end block of a procedure. With the standard options it searches the code in front for other procedure begin..end blocks. If it does not find the code it searches behind the code, then in all units of the project (or package) and finally in the example code of the options. For instance it finds:
33	32
34	33		``` pascal
35	34		procedure TMainForm.FormPaint(Sender: TObject);
36	35		begin
37	36		with Canvas do FillRect(0,0,Width,Height);
38	37		end;
39	38		```
40	39
41	40		The indentation of the first token with is 2. The indentation of the first token of clipboard code is 4, so the indenter unindents the code by 2, resulting in:
42	41
43	42		``` pascal
44	43		procedure TMainForm.Button1Click(Sender: TObject);
45	44		begin
46	45		if Visible then
47	46		begin
48	47		end;\|
49	48		end;
50	49		```
51	50
52	51		The indenter always indents the whole block, not every line. For example pasting
53	52
54	53		``` pascal
55	54		DoSomething(Param1,
56	55		Param2);
57	56		```
58	57
59	58		will keep the indent both lines by the same amount, keeping the two Params aligned.
60	59
61	60		The indenter scans what is inserted. For instance pasting
62	61
63	62		``` pascal
64	63		end;
65	64		```
66	65
67	66		will end the the begin block, resulting in:
68	67
69	68		``` pascal
70	69		procedure TMainForm.Button1Click(Sender: TObject);
71	70		begin
72	71		end;\|
73	72		end;
74	73		```
75	74
76	75		# Examples
77	76
78	77		Sometimes record and classes are aligned to the keywords instead of start of last line.
79	78
80	79		``` pascal
81	80		type TMyRecord = record
82	81		i: integer;
83	82		end;
84	83		```
85	84
86	85		At the moment the indenter supports only amount of spaces, not aligning to keywords or symbols.
87	86
88	87		## begin end
89	88
90	89		``` pascal
91	90		procedure Do;
92	91		var
93	92		i: integer; // indent after var
94	93		begin // no indent after procedure, no indent before procedure-begin, unindent after var section
95	94		if expr then
96	95		begin // no indent after then, no indent before then-begin
97	96		Code; // indent after begin
98	97		end; // unindent before end
99	98		end;
100	99		```
101	100
102	101		``` pascal
103	102		procedure Do;
104	103		begin
105	104		if expr then begin
106	105		Code; // indent after begin
107	106		end; // unindent before end
108	107		end;
109	108		```
110	109
111	110		``` pascal
112	111		procedure Do;
113	112		begin
114	113		if expr then
115	114		begin // indent after then and unindent after then-statement
116	115		Code; // no indent after begin
117	116		end; // no unindent before end
118	117		end;
119	118		```
120	119
121	120		``` pascal
122	121		procedure Do;
123	122		begin
124	123		if expr then
125	124		begin // indent after then and unindent after then-statement
126	125		Code; // indent after begin
127	126		end; // unindent before end
128	127		end;
129	128		```
130	129
131	130		## repeat until
132	131
133	132		I never saw code other than this:
134	133
135	134		``` pascal
136	135		repeat
137	136		Code; // indent after repeat
138	137		until ; // unindent before until
139	138		```
140	139
141	140		## try finally
142	141
143	142		I never saw code other than this:
144	143
145	144		``` pascal
146	145		try
147	146		Code; // indent after try
148	147		finally // unindent before finally
149	148		on e do ; // indent after finally
150	149		end; // unindent before finally-end
151	150		```
152	151
153	152		## case of end
154	153
155	154		``` pascal
156	155		case expr of
157	156		1: ; // no indent after case-of
158	157		2:
159	158		Code; // indent after case-colon
160	159		3:
161	160		begin // indent after case-colon
162	161		Code; // indent after case-colon-begin
163	162		end; // unindent before case-colon-end, unindent after case-colon-end
164	163		else // no indent case-else
165	164		Code; // indent after case-else
166	165		end; // unindent after case-else statements
167	166		```
168	167
169	168		``` pascal
170	169		case expr of
171	170
172	171		1: ; // indent after case-of
173	172
174	173		2:
175	174		begin // no indent after case-colon
176	175		end;
177	176		else // no indent before case-else
178	177		end; // no indent before case-end
179	178		```
180	179
181	180		## if then else
182	181
183	182		``` pascal
184	183		if expr then
185	184		Code
186	185		else
187	186		Code;
188	187		```
189	188
190	189		``` pascal
191	190		if expr or
192	191		expr or
193	192		expr then
194	193		Code
195	194		else
196	195		Code;
197	196		```
198	197
199	198		``` pascal
200	199		if expr
201	200		or expr
202	201		then
203	202		Code
204	203		else
205	204		Code;
206	205		```
207	206
208	207		``` pascal
209	208		if SrcEdit.SelectionAvailable
210	209		and SrcEdit.CaretInSelection(CaretPos)
211	210		then Expression := SrcEdit.GetText(True)
212	211		else Expression := Identifier;
213	212		if not DebugBoss.Evaluate(Expression, DebugEval)
214	213		or (DebugEval = '')
215	214		then DebugEval := '???';
216	215		```
217	216
218	217		---
219	218		From the Free Pascal wiki, page "Fully automatic indentation", as it stood on 2020-02-16 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
220	219		Category: Lazarus

Back to history