Mercurial > hg > RemoteEditor > vim7

comparison src/testdir/test3.in @ 0:76efa0be13f1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial revision
author atsuki
date Sat, 10 Nov 2007 15:07:22 +0900
parents
children e170173ecb68
comparison
equal deleted inserted replaced
-1:000000000000 0:76efa0be13f1
1 /* vim: set cin ts=4 sw=4 : */
2
3 Test for 'cindent'
4
5 STARTTEST
6 :so small.vim
7 :set nocompatible viminfo+=nviminfo
8 :edit " read modeline
9 /start of AUTO
10 =/end of AUTO
11 ENDTEST
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
204 func(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;
283 label :
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
294 char *(array[100]) = {
295 "testje",
296 "foo",
297 "bar",
298 }
299
300 enum soppie
301 {
302 yes = 0,
303 no,
304 maybe
305 };
306
307 typedef 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
378 main ()
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
403 label: if (asdf)
404 here;
405
406 label: if (asdf &&
407 asdfasdf)
408 {
409 }
410
411 label: if (asdf &&
412 asdfasdf) {
413 there;
414 }
415
416 label: 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
446 class bob
447 {
448 int foo() {return 1;}
449 int bar;
450 }
451
452 main()
453 {
454 while(1)
455 if (foo)
456 {
457 bar;
458 }
459 else {
460 asdf;
461 }
462 misplacedline;
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 {
473 if (1) {i += 4;}
474 where_am_i;
475 return 0;
476 }
477
478 {
479 {
480 } // sdf(asdf
481 if (asdf)
482 asd;
483 }
484
485 {
486 label1:
487 label2:
488 }
489
490 {
491 int fooRet = foo(pBar1, false /*fKB*/,
492 true /*fPTB*/, 3 /*nT*/, false /*fDF*/);
493 f() {
494 for ( i = 0;
495 i < m;
496 /* c */ i++ ) {
497 a = b;
498 }
499 }
500 }
501
502 {
503 f1(/*comment*/);
504 f2();
505 }
506
507 {
508 do {
509 if (foo) {
510 } else
511 ;
512 } while (foo);
513 foo(); // was wrong
514 }
515
516 int x; // no extra indent because of the ;
517 void func()
518 {
519 }
520
521 char *tab[] = {"aaa",
522 "};", /* }; */ NULL}
523 int indented;
524 {}
525
526 char *a[] = {"aaa", "bbb",
527 "ccc", NULL};
528 // here
529
530 char *tab[] = {"aaa",
531 "xx", /* xx */}; /* asdf */
532 int 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
545 int foo,
546 bar;
547 int foo;
548
549 #if defined(foo) \
550 && defined(bar)
551 char * xx = "asdf\
552 foo\
553 bor";
554 int x;
555
556 char *foo = "asdf\
557 asdf\
558 asdf",
559 *bar;
560
561 void f()
562 {
563 #if defined(foo) \
564 && defined(bar)
565 char *foo = "asdf\
566 asdf\
567 asdf",
568 *bar;
569 {
570 int i;
571 char *foo = "asdf\
572 asdf\
573 asdf",
574 *bar;
575 }
576 #endif
577 }
578 #endif
579
580 int y; // comment
581 // comment
582
583 // comment
584
585 {
586 Constructor(int a,
587 int b ) : BaseClass(a)
588 {
589 }
590 }
591
592 void 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
615 Constructor::Constructor(int a,
616 int b
617 ) :
618 BaseClass(a,
619 b,
620 c),
621 mMember(b),
622 {
623 }
624
625 Constructor::Constructor(int a,
626 int b ) :
627 BaseClass(a)
628 {
629 }
630
631 Constructor::Constructor(int a,
632 int b ) /*x*/ : /*x*/ BaseClass(a),
633 member(b)
634 {
635 }
636
637 class 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
659 public: // <-- this was incoreectly indented before!!
660 void testfall();
661 protected:
662 void testfall();
663 };
664
665 class CAbc : public BaseClass1,
666 protected BaseClass2
667 {
668 };
669
670 static 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
686 static struct
687 {
688 int a;
689 int b;
690 } variable[COUNT] =
691 {
692 { 123, 456 },
693 { 123, 456 }
694 };
695
696 void 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
726 foo()
727 {
728 a = cond ? foo() : asdf
729 + asdf;
730
731 a = cond ?
732 foo() : asdf
733 + asdf;
734 }
735
736 int main(void)
737 {
738 if (a)
739 if (b)
740 2;
741 else 3;
742 next_line_of_code();
743 }
744
745 barry()
746 {
747 Foo::Foo (int one,
748 int two)
749 : something(4)
750 {}
751 }
752
753 barry()
754 {
755 Foo::Foo (int one, int two)
756 : something(4)
757 {}
758 }
759
760 Constructor::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
779 int main ()
780 {
781 switch (c)
782 {
783 case 'c': if (cond)
784 {
785 }
786 }
787 }
788
789 main()
790 {
791 (void) MyFancyFuasdfadsfnction(
792 argument);
793 }
794
795 main()
796 {
797 char foo[] = "/*";
798 /* as
799 df */
800 hello
801 }
802 /* end of AUTO */
803
804 STARTTEST
805 :set tw=0 wm=60 columns=80 noai fo=croq
806 /serious/e
807 a about life, the universe, and the rest
808 ENDTEST
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
819 STARTTEST
820 :set nocin
821 /comments
822 joabout life/happens
823 jothere/below
824 oline/this
825 Ohello
826 ENDTEST
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
844 STARTTEST
845 :set cin
846 /vec2
847 ==
848 ENDTEST
849
850 {
851 var = this + that + vec[0] * vec[0]
852 + vec[1] * vec[1]
853 + vec2[2] * vec[2];
854 }
855
856 STARTTEST
857 :set cin
858 :set cino=}4
859 /testing1
860 k2==/testing2
861 k2==
862 ENDTEST
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
879 STARTTEST
880 :set cin
881 :set cino=(0,)20
882 /main
883 =][
884 ENDTEST
885
886 main ( 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
908 STARTTEST
909 :set cin
910 :set cino=
911 ]]=][
912 ENDTEST
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
928 STARTTEST
929 ]]=][
930 ENDTEST
931
932 void f()
933 {
934 if ( k() ) {
935 l();
936
937 } else { /* Start (two words) end */
938 m();
939 }
940
941 n();
942 }
943
944 STARTTEST
945 :set cino={s,e-s
946 ]]=][
947 ENDTEST
948
949 void 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
960 STARTTEST
961 :set cino={s,fs
962 ]]=/ foo
963 ENDTEST
964
965 void 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
987 void func(void)
988 {
989 a = 1;
990 {
991 b = 2;
992 }
993 c = 3;
994 d = 4;
995 }
996 /* foo */
997
998 STARTTEST
999 :set cino=
1000 /while
1001 ohere
1002 ENDTEST
1003
1004 a()
1005 {
1006 do {
1007 a = a +
1008 a;
1009 } while ( a ); /* add text under this line */
1010 if ( a )
1011 a;
1012 }
1013
1014 STARTTEST
1015 :set cino= com=
1016 /comment
1017 olabel2: b();
1018 label3 /* post */:
1019 /* pre */ label4:
1020 f(/*com*/);
1021 if (/*com*/)
1022 cmd();
1023 ENDTEST
1024
1025 a()
1026 {
1027 label1:
1028 /* hmm */
1029 // comment
1030 }
1031
1032 STARTTEST
1033 :set comments& comments^=s:/*,m:**,ex:*/
1034 /simple
1035 =5j
1036 ENDTEST
1037
1038 /*
1039 * A simple comment
1040 */
1041
1042 /*
1043 ** A different comment
1044 */
1045
1046 STARTTEST
1047 :set cino=c0
1048 :set comments& comments-=s1:/* comments^=s0:/*
1049 2kdd]]=][
1050 ENDTEST
1051
1052 void f()
1053 {
1054
1055 /*********
1056 A comment.
1057 *********/
1058 }
1059
1060 STARTTEST
1061 :set cino=c0,C1
1062 :set comments& comments-=s1:/* comments^=s0:/*
1063 2kdd]]=][
1064 ENDTEST
1065
1066 void f()
1067 {
1068
1069 /*********
1070 A comment.
1071 *********/
1072 }
1073
1074 STARTTEST
1075 :set cino=
1076 ]]=][
1077 ENDTEST
1078
1079 void f()
1080 {
1081 c = c1 &&
1082 (
1083 c2 ||
1084 c3
1085 ) && c4;
1086 }
1087
1088 STARTTEST
1089 :set cino=(s
1090 2kdd]]=][
1091 ENDTEST
1092
1093 void f()
1094 {
1095 c = c1 &&
1096 (
1097 c2 ||
1098 c3
1099 ) && c4;
1100 }
1101
1102 STARTTEST
1103 :set cino=(s,U1
1104 2kdd]]=][
1105 ENDTEST
1106
1107 void f()
1108 {
1109 c = c1 &&
1110 (
1111 c2 ||
1112 c3
1113 ) && c4;
1114 }
1115
1116 STARTTEST
1117 :set cino=(0
1118 2kdd]]=][
1119 ENDTEST
1120
1121 void f()
1122 {
1123 if ( c1
1124 && ( c2
1125 || c3))
1126 foo;
1127 }
1128
1129 STARTTEST
1130 :set cino=(0,w1
1131 2kdd]]=][
1132 ENDTEST
1133
1134 void f()
1135 {
1136 if ( c1
1137 && ( c2
1138 || c3))
1139 foo;
1140 }
1141
1142 STARTTEST
1143 :set cino=(s
1144 2kdd]]=][
1145 ENDTEST
1146
1147 void f()
1148 {
1149 c = c1 && (
1150 c2 ||
1151 c3
1152 ) && c4;
1153 if (
1154 c1 && c2
1155 )
1156 foo;
1157 }
1158
1159 STARTTEST
1160 :set cino=(s,m1
1161 2kdd]]=][
1162 ENDTEST
1163
1164 void f()
1165 {
1166 c = c1 && (
1167 c2 ||
1168 c3
1169 ) && c4;
1170 if (
1171 c1 && c2
1172 )
1173 foo;
1174 }
1175
1176 STARTTEST
1177 :set cino=b1
1178 2kdd]]=][
1179 ENDTEST
1180
1181 void f()
1182 {
1183 switch (x)
1184 {
1185 case 1:
1186 a = b;
1187 break;
1188 default:
1189 a = 0;
1190 break;
1191 }
1192 }
1193
1194 STARTTEST
1195 :set cino=(0,W5
1196 2kdd]]=][
1197 ENDTEST
1198
1199 void f()
1200 {
1201 invokeme(
1202 argu,
1203 ment);
1204 invokeme(
1205 argu,
1206 ment
1207 );
1208 invokeme(argu,
1209 ment
1210 );
1211 }
1212
1213 STARTTEST
1214 :set cino=/6
1215 2kdd]]=][
1216 ENDTEST
1217
1218 void f()
1219 {
1220 statement;
1221 // comment 1
1222 // comment 2
1223 }
1224
1225 STARTTEST
1226 :set cino=
1227 2kdd]]/comment 1/+1
1228 ==
1229 ENDTEST
1230
1231 void f()
1232 {
1233 statement;
1234 // comment 1
1235 // comment 2
1236 }
1237
1238 STARTTEST
1239 :set cino=g0
1240 2kdd]]=][
1241 ENDTEST
1242
1243 class CAbc
1244 {
1245 int Test() { return FALSE; }
1246
1247 public: // comment
1248 void testfall();
1249 protected:
1250 void testfall();
1251 };
1252
1253 STARTTEST
1254 :set cino=+20
1255 2kdd]]=][
1256 ENDTEST
1257
1258 void
1259 foo()
1260 {
1261 if (a)
1262 {
1263 } else
1264 asdf;
1265 }
1266
1267 STARTTEST
1268 :set cino=(0,W2s
1269 2kdd]]=][
1270 ENDTEST
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
1309 STARTTEST
1310 :set cino=M1
1311 2kdd]]=][
1312 ENDTEST
1313
1314 int main ()
1315 {
1316 if (cond1 &&
1317 cond2
1318 )
1319 foo;
1320 }
1321
1322 STARTTEST
1323 :g/^STARTTEST/.,/^ENDTEST/d
1324 :1;/start of AUTO/,$wq! test.out
1325 ENDTEST