1/* vim: set cin ts=4 sw=4 : */
2
3Test for 'cindent'
4
5STARTTEST
6:so small.vim
7:set nocompatible viminfo+=nviminfo modeline
8:edit                " read modeline
9/start of AUTO
10=/end of AUTO
11ENDTEST
12
13/* start of AUTO matically checked vim: set ts=4 : */
14{
15	if (test)
16		cmd1;
17	cmd2;
18}
19
20{
21	if (test)
22		cmd1;
23	else
24		cmd2;
25}
26
27{
28	if (test)
29	{
30		cmd1;
31		cmd2;
32	}
33}
34
35{
36	if (test)
37	{
38		cmd1;
39		else
40	}
41}
42
43{
44	while (this)
45		if (test)
46			cmd1;
47	cmd2;
48}
49
50{
51	while (this)
52		if (test)
53			cmd1;
54		else
55			cmd2;
56}
57
58{
59	if (test)
60	{
61		cmd;
62	}
63
64	if (test)
65		cmd;
66}
67
68{
69	if (test) {
70		cmd;
71	}
72
73	if (test) cmd;
74}
75
76{
77	cmd1;
78	for (blah)
79		while (this)
80			if (test)
81				cmd2;
82	cmd3;
83}
84
85{
86	cmd1;
87	for (blah)
88		while (this)
89			if (test)
90				cmd2;
91	cmd3;
92
93	if (test)
94	{
95		cmd1;
96		cmd2;
97		cmd3;
98	}
99}
100
101
102/* Test for 'cindent' do/while mixed with if/else: */
103
104{
105	do
106		if (asdf)
107			asdfasd;
108	while (cond);
109
110	do
111		if (asdf)
112			while (asdf)
113				asdf;
114	while (asdf);
115}
116
117/* Test for 'cindent' with two ) on a continuation line */
118{
119	if (asdfasdf;asldkfj asdlkfj as;ldkfj sal;d
120			aal;sdkjf  ( ;asldfkja;sldfk
121					al;sdjfka ;slkdf ) sa;ldkjfsa dlk;)
122		line up here;
123}
124
125
126/* C++ tests: */
127
128// foo()		these three lines should remain in column 0
129// {
130// }
131
132/* Test for continuation and unterminated lines: */
133{
134	i = 99 + 14325 +
135		21345 +
136		21345 +
137		21345 + ( 21345 +
138				21345) +
139		2345 +
140		1234;
141	c = 1;
142}
143
144/*
145   testje for indent with empty line
146
147   here */
148
149{
150	if (testing &&
151			not a joke ||
152			line up here)
153		hay;
154	if (testing &&
155			(not a joke || testing
156			)line up here)
157		hay;
158	if (testing &&
159			(not a joke || testing
160			 line up here))
161		hay;
162}
163
164
165{
166	switch (c)
167	{
168		case xx:
169			do
170				if (asdf)
171					do
172						asdfasdf;
173					while (asdf);
174				else
175					asdfasdf;
176			while (cond);
177		case yy:
178		case xx:
179		case zz:
180			testing;
181	}
182}
183
184{
185	if (cond) {
186		foo;
187	}
188	else
189	{
190		bar;
191	}
192}
193
194{
195	if (alskdfj ;alsdkfjal;skdjf (;sadlkfsa ;dlkf j;alksdfj ;alskdjf
196			alsdkfj (asldk;fj
197					awith cino=(0 ;lf this one goes to below the paren with ==
198							;laksjfd ;lsakdjf ;alskdf asd)
199					asdfasdf;)))
200		asdfasdf;
201}
202
203	int
204func(a, b)
205	int a;
206	int c;
207{
208	if (c1 && (c2 ||
209			c3))
210		foo;
211	if (c1 &&
212			(c2 || c3)
213	   )
214}
215
216{
217	while (asd)
218	{
219		if (asdf)
220			if (test)
221				if (that)
222				{
223					if (asdf)
224						do
225							cdasd;
226						while (as
227								df);
228				}
229				else
230					if (asdf)
231						asdf;
232					else
233						asdf;
234		asdf;
235	}
236}
237
238{
239	s = "/*"; b = ';'
240		s = "/*"; b = ';';
241	a = b;
242}
243
244{
245	switch (a)
246	{
247		case a:
248			switch (t)
249			{
250				case 1:
251					cmd;
252					break;
253				case 2:
254					cmd;
255					break;
256			}
257			cmd;
258			break;
259		case b:
260			{
261				int i;
262				cmd;
263			}
264			break;
265		case c: {
266					int i;
267					cmd;
268				}
269		case d: if (cond &&
270						test) {		/* this line doesn't work right */
271					int i;
272					cmd;
273				}
274				break;
275	}
276}
277
278{
279	if (!(vim_strchr(p_cpo, CPO_BUFOPTGLOB) != NULL && entering) &&
280			(bp_to->b_p_initialized ||
281			 (!entering && vim_strchr(p_cpo, CPO_BUFOPT) != NULL)))
282		return;
283label :
284	asdf = asdf ?
285		asdf : asdf;
286	asdf = asdf ?
287		asdf: asdf;
288}
289
290/* Special Comments	: This function has the added complexity (compared  */
291/*					: to addtolist) of having to check for a detail     */
292/*					: texture and add that to the list first.	 	    */
293
294char *(array[100]) = {
295	"testje",
296	"foo",
297	"bar",
298}
299
300enum soppie
301{
302	yes = 0,
303	no,
304	maybe
305};
306
307typedef enum soppie
308{
309	yes = 0,
310	no,
311	maybe
312};
313
314{
315	int a,
316		b;
317}
318
319{
320	struct Type
321	{
322		int i;
323		char *str;
324	} var[] =
325	{
326		0, "zero",
327		1, "one",
328		2, "two",
329		3, "three"
330	};
331
332	float matrix[3][3] =
333	{
334		{
335			0,
336			1,
337			2
338		},
339		{
340			3,
341			4,
342			5
343		},
344		{
345			6,
346			7,
347			8
348		}
349	};
350}
351
352{
353	/* blah ( blah */
354	/* where does this go? */
355
356	/* blah ( blah */
357	cmd;
358
359	func(arg1,
360			/* comment */
361			arg2);
362	a;
363	{
364		b;
365		{
366			c; /* Hey, NOW it indents?! */
367		}
368	}
369
370	{
371		func(arg1,
372				arg2,
373				arg3);
374		/* Hey, what am I doing here?  Is this coz of the ","? */
375	}
376}
377
378main ()
379{
380	if (cond)
381	{
382		a = b;
383	}
384	if (cond) {
385		a = c;
386	}
387	if (cond)
388		a = d;
389	return;
390}
391
392{
393	case 2: if (asdf &&
394					asdfasdf)
395				aasdf;
396			a = 9;
397	case 3: if (asdf)
398				aasdf;
399			a = 9;
400	case 4:    x = 1;
401			   y = 2;
402
403label:	if (asdf)
404			here;
405
406label:  if (asdf &&
407				asdfasdf)
408		{
409		}
410
411label:  if (asdf &&
412				asdfasdf) {
413			there;
414		}
415
416label:  if (asdf &&
417				asdfasdf)
418			there;
419}
420
421{
422	/*
423	   hello with ":set comments= cino=c5"
424	 */
425
426	/*
427	   hello with ":set comments= cino="
428	 */
429}
430
431
432{
433	if (a < b) {
434		a = a + 1;
435	} else
436		a = a + 2;
437
438	if (a)
439		do {
440			testing;
441		} while (asdfasdf);
442	a = b + 1;
443	asdfasdf
444}
445
446class bob
447{
448	int foo() {return 1;}
449		int bar;
450}
451
452main()
453{
454while(1)
455if (foo)
456{
457bar;
458}
459else {
460asdf;
461}
462misplacedline;
463}
464
465{
466	if (clipboard.state == SELECT_DONE
467	&& ((row == clipboard.start.lnum
468	&& col >= clipboard.start.col)
469	|| row > clipboard.start.lnum))
470}
471
472{
473if (1) {i += 4;}
474where_am_i;
475return 0;
476}
477
478{
479{
480} // sdf(asdf
481if (asdf)
482asd;
483}
484
485{
486label1:
487label2:
488}
489
490{
491int fooRet = foo(pBar1, false /*fKB*/,
492	true /*fPTB*/, 3 /*nT*/, false /*fDF*/);
493f() {
494for ( i = 0;
495	i < m;
496	/* c */ i++ ) {
497a = b;
498}
499}
500}
501
502{
503	f1(/*comment*/);
504	f2();
505}
506
507{
508do {
509if (foo) {
510} else
511;
512} while (foo);
513foo();	// was wrong
514}
515
516int x;	    // no extra indent because of the ;
517void func()
518{
519}
520
521char *tab[] = {"aaa",
522	"};", /* }; */ NULL}
523	int indented;
524{}
525
526char *a[] = {"aaa", "bbb",
527	"ccc", NULL};
528// here
529
530char *tab[] = {"aaa",
531	"xx", /* xx */};    /* asdf */
532int not_indented;
533
534{
535	do {
536		switch (bla)
537		{
538			case 1: if (foo)
539						bar;
540		}
541	} while (boo);
542					wrong;
543}
544
545int	foo,
546	bar;
547int foo;
548
549#if defined(foo) \
550	&& defined(bar)
551char * xx = "asdf\
552	foo\
553	bor";
554int x;
555
556char    *foo = "asdf\
557	asdf\
558	asdf",
559	*bar;
560
561void f()
562{
563#if defined(foo) \
564	&& defined(bar)
565char    *foo = "asdf\
566	asdf\
567	asdf",
568	*bar;
569	{
570	int i;
571char    *foo = "asdf\
572	asdf\
573	asdf",
574	*bar;
575	}
576#endif
577}
578#endif
579
580int y;		// comment
581		// comment
582
583	// comment
584
585{
586	Constructor(int a,
587			int b )  : BaseClass(a)
588	{
589	}
590}
591
592void foo()
593{
594	char one,
595	two;
596	struct bla piet,
597	jan;
598	enum foo kees,
599	jannie;
600	static unsigned sdf,
601	krap;
602	unsigned int piet,
603	jan;
604	int
605	kees,
606	jan;
607}
608
609{
610	t(int f,
611			int d);		// )
612	d();
613}
614
615Constructor::Constructor(int a,
616                         int b
617                        )  :
618   BaseClass(a,
619             b,
620             c),
621   mMember(b),
622{
623}
624
625Constructor::Constructor(int a,
626                         int b )  :
627   BaseClass(a)
628{
629}
630
631Constructor::Constructor(int a,
632                         int b ) /*x*/ : /*x*/ BaseClass(a),
633                                               member(b)
634{
635}
636
637class CAbc :
638   public BaseClass1,
639   protected BaseClass2
640{
641   int Test() { return FALSE; }
642   int Test1() { return TRUE; }
643
644   CAbc(int a, int b )  :
645      BaseClass(a)
646   {
647      switch(xxx)
648      {
649         case abc:
650            asdf();
651            break;
652
653         case 999:
654            baer();
655            break;
656      }
657   }
658
659public: // <-- this was incoreectly indented before!!
660   void testfall();
661protected:
662   void testfall();
663};
664
665class CAbc : public BaseClass1,
666             protected BaseClass2
667{
668};
669
670static struct
671{
672    int a;
673    int b;
674} variable[COUNT] =
675{
676    {
677        123,
678        456
679    },
680	{
681        123,
682        456
683    }
684};
685
686static struct
687{
688    int a;
689    int b;
690} variable[COUNT] =
691{
692    { 123, 456 },
693	{ 123, 456 }
694};
695
696void asdf()		/* ind_maxparen may cause trouble here */
697{
698	if ((0
699				&& 1
700				&& 1
701				&& 1
702				&& 1
703				&& 1
704				&& 1
705				&& 1
706				&& 1
707				&& 1
708				&& 1
709				&& 1
710				&& 1
711				&& 1
712				&& 1
713				&& 1
714				&& 1
715				&& 1
716				&& 1
717				&& 1
718				&& 1
719				&& 1
720				&& 1
721				&& 1
722				&& 1
723				&& 1)) break;
724}
725
726foo()
727{
728	a = cond ? foo() : asdf
729					   + asdf;
730
731	a = cond ?
732		foo() : asdf
733				+ asdf;
734}
735
736int  main(void)
737{
738	if (a)
739		if (b)
740			2;
741		else 3;
742	next_line_of_code();
743}
744
745barry()
746{
747	Foo::Foo (int one,
748			int two)
749		: something(4)
750	{}
751}
752
753barry()
754{
755	Foo::Foo (int one, int two)
756		: something(4)
757	{}
758}
759
760Constructor::Constructor(int a,
761		int b
762		)  :
763	BaseClass(a,
764			b,
765			c),
766	mMember(b)
767{
768}
769       int main ()
770       {
771	 if (lala)
772	   do
773	     ++(*lolo);
774	   while (lili
775		  && lele);
776	   lulu;
777       }
778
779int main ()
780{
781switch (c)
782{
783case 'c': if (cond)
784{
785}
786}
787}
788
789main()
790{
791	(void) MyFancyFuasdfadsfnction(
792			argument);
793}
794
795main()
796{
797	char	foo[] = "/*";
798	/* as
799	df */
800		hello
801}
802/* end of AUTO */
803
804STARTTEST
805:set tw=0 wm=60 columns=80 noai fo=croq
806/serious/e
807a about life, the universe, and the rest
808ENDTEST
809
810{
811
812/* this is
813 * a real serious important big
814 * comment
815 */
816	/* insert " about life, the universe, and the rest" after "serious" */
817}
818
819STARTTEST
820:set nocin
821/comments
822joabout life/happens
823jothere/below
824oline/this
825Ohello
826ENDTEST
827
828{
829	/*
830	 * Testing for comments, without 'cin' set
831	 */
832
833/*
834* what happens here?
835*/
836
837	/*
838	   the end of the comment, try inserting a line below */
839
840		/* how about
841		                this one */
842}
843
844STARTTEST
845:set cin
846/vec2
847==
848ENDTEST
849
850{
851    var = this + that + vec[0] * vec[0]
852				      + vec[1] * vec[1]
853					  + vec2[2] * vec[2];
854}
855
856STARTTEST
857:set cin
858:set cino=}4
859/testing1
860k2==/testing2
861k2==
862ENDTEST
863
864{
865		asdf asdflkajds f;
866	if (tes & ting) {
867		asdf asdf asdf ;
868		asdfa sdf asdf;
869		}
870	testing1;
871	if (tes & ting)
872	{
873		asdf asdf asdf ;
874		asdfa sdf asdf;
875		}
876	testing2;
877}
878
879STARTTEST
880:set cin
881:set cino=(0,)20
882/main
883=][
884ENDTEST
885
886main ( int first_par, /*
887                       * Comment for
888                       * first par
889                       */
890          int second_par /*
891                       * Comment for
892                       * second par
893                       */
894     )
895{
896	func( first_par, /*
897                      * Comment for
898                      * first par
899                      */
900    second_par /*
901                      * Comment for
902                      * second par
903                      */
904        );
905
906}
907
908STARTTEST
909:set cin
910:set cino=
911]]=][
912ENDTEST
913
914{
915	do
916	{
917		if ()
918		{
919			if ()
920				asdf;
921			else
922				asdf;
923		}
924	} while ();
925			cmd;		/* this should go under the } */
926}
927
928STARTTEST
929]]=][
930ENDTEST
931
932void f()
933{
934    if ( k() ) {
935        l();
936
937    } else { /* Start (two words) end */
938        m();
939    }
940
941    n();
942}
943
944STARTTEST
945:set cino={s,e-s
946]]=][
947ENDTEST
948
949void f()
950{
951    if ( k() )
952	{
953        l();
954    } else { /* Start (two words) end */
955        m();
956    }
957		n();	/* should be under the if () */
958}
959
960STARTTEST
961:set cino={s,fs
962]]=/ foo
963ENDTEST
964
965void bar(void)
966{
967	static array[2][2] =
968	{
969		{ 1, 2 },
970		{ 3, 4 },
971	}
972
973	while (a)
974	{
975		foo(&a);
976	}
977
978	{
979		int a;
980		{
981			a = a + 1;
982		}
983	}
984	b = a;
985	}
986
987void func(void)
988	{
989	a = 1;
990	{
991		b = 2;
992	}
993	c = 3;
994	d = 4;
995	}
996/* foo */
997
998STARTTEST
999:set cino=
1000/while
1001ohere
1002ENDTEST
1003
1004a()
1005{
1006  do {
1007    a = a +
1008      a;
1009  } while ( a );		/* add text under this line */
1010    if ( a )
1011      a;
1012}
1013
1014STARTTEST
1015:set cino= com=
1016/comment
1017olabel2: b();
1018label3 /* post */:
1019/* pre */ label4:
1020f(/*com*/);
1021if (/*com*/)
1022cmd();
1023ENDTEST
1024
1025a()
1026{
1027label1:
1028            /* hmm */
1029            // comment
1030}
1031
1032STARTTEST
1033:set comments& comments^=s:/*,m:**,ex:*/
1034/simple
1035=5j
1036ENDTEST
1037
1038/*
1039  * A simple comment
1040   */
1041
1042/*
1043  ** A different comment
1044   */
1045
1046STARTTEST
1047:set cino=c0
1048:set comments& comments-=s1:/* comments^=s0:/*
10492kdd]]=][
1050ENDTEST
1051
1052void f()
1053{
1054
1055	/*********
1056  A comment.
1057*********/
1058}
1059
1060STARTTEST
1061:set cino=c0,C1
1062:set comments& comments-=s1:/* comments^=s0:/*
10632kdd]]=][
1064ENDTEST
1065
1066void f()
1067{
1068
1069	/*********
1070  A comment.
1071*********/
1072}
1073
1074STARTTEST
1075:set cino=
1076]]=][
1077ENDTEST
1078
1079void f()
1080{
1081	c = c1 &&
1082	(
1083	c2 ||
1084	c3
1085	) && c4;
1086}
1087
1088STARTTEST
1089:set cino=(s
10902kdd]]=][
1091ENDTEST
1092
1093void f()
1094{
1095	c = c1 &&
1096	(
1097	c2 ||
1098	c3
1099	) && c4;
1100}
1101
1102STARTTEST
1103:set cino=(s,U1
11042kdd]]=][
1105ENDTEST
1106
1107void f()
1108{
1109	c = c1 &&
1110	(
1111	c2 ||
1112	c3
1113	) && c4;
1114}
1115
1116STARTTEST
1117:set cino=(0
11182kdd]]=][
1119ENDTEST
1120
1121void f()
1122{
1123	if (   c1
1124	&& (   c2
1125	|| c3))
1126	foo;
1127}
1128
1129STARTTEST
1130:set cino=(0,w1
11312kdd]]=][
1132ENDTEST
1133
1134void f()
1135{
1136	if (   c1
1137	&& (   c2
1138	|| c3))
1139	foo;
1140}
1141
1142STARTTEST
1143:set cino=(s
11442kdd]]=][
1145ENDTEST
1146
1147void f()
1148{
1149	c = c1 && (
1150	c2 ||
1151	c3
1152	) && c4;
1153	if (
1154	c1 && c2
1155	)
1156	foo;
1157}
1158
1159STARTTEST
1160:set cino=(s,m1
11612kdd]]=][
1162ENDTEST
1163
1164void f()
1165{
1166	c = c1 && (
1167	c2 ||
1168	c3
1169	) && c4;
1170	if (
1171	c1 && c2
1172	)
1173	foo;
1174}
1175
1176STARTTEST
1177:set cino=b1
11782kdd]]=][
1179ENDTEST
1180
1181void f()
1182{
1183	switch (x)
1184	{
1185		case 1:
1186			a = b;
1187			break;
1188		default:
1189			a = 0;
1190			break;
1191	}
1192}
1193
1194STARTTEST
1195:set cino=(0,W5
11962kdd]]=][
1197ENDTEST
1198
1199void f()
1200{
1201	invokeme(
1202	argu,
1203	ment);
1204	invokeme(
1205	argu,
1206	ment
1207	);
1208	invokeme(argu,
1209	ment
1210	);
1211}
1212
1213STARTTEST
1214:set cino=/6
12152kdd]]=][
1216ENDTEST
1217
1218void f()
1219{
1220	statement;
1221		// comment 1
1222	// comment 2
1223}
1224
1225STARTTEST
1226:set cino=
12272kdd]]/comment 1/+1
1228==
1229ENDTEST
1230
1231void f()
1232{
1233	statement;
1234	   // comment 1
1235	// comment 2
1236}
1237
1238STARTTEST
1239:set cino=g0
12402kdd]]=][
1241ENDTEST
1242
1243class CAbc
1244{
1245   int Test() { return FALSE; }
1246
1247public: // comment
1248   void testfall();
1249protected:
1250   void testfall();
1251};
1252
1253STARTTEST
1254:set cino=+20
12552kdd]]=][
1256ENDTEST
1257
1258	void
1259foo()
1260{
1261	if (a)
1262	{
1263	} else
1264		asdf;
1265}
1266
1267STARTTEST
1268:set cino=(0,W2s
12692kdd]]=][
1270ENDTEST
1271
1272{
1273   averylongfunctionnamelongfunctionnameaverylongfunctionname()->asd(
1274         asdasdf,
1275         func(asdf,
1276              asdfadsf),
1277         asdfasdf
1278         );
1279
1280   /* those are ugly, but consequent */
1281
1282   func()->asd(asdasdf,
1283               averylongfunctionname(
1284                     abc,
1285                     dec)->averylongfunctionname(
1286                           asdfadsf,
1287                           asdfasdf,
1288                           asdfasdf,
1289                           ),
1290               func(asdfadf,
1291                    asdfasdf
1292                   ),
1293               asdasdf
1294              );
1295
1296   averylongfunctionnameaverylongfunctionnameavery()->asd(fasdf(
1297               abc,
1298               dec)->asdfasdfasdf(
1299                     asdfadsf,
1300                     asdfasdf,
1301                     asdfasdf,
1302                     ),
1303         func(asdfadf,
1304              asdfasdf),
1305         asdasdf
1306         );
1307}
1308
1309STARTTEST
1310:set cino=M1
13112kdd]]=][
1312ENDTEST
1313
1314int main ()
1315{
1316	if (cond1 &&
1317			cond2
1318			)
1319		foo;
1320}
1321
1322STARTTEST
1323:g/^STARTTEST/.,/^ENDTEST/d
1324:1;/start of AUTO/,$wq! test.out
1325ENDTEST
1326