| /* vim: set cin ts=4 sw=4 : */ |
| |
| Test for 'cindent' |
| |
| STARTTEST |
| :so small.vim |
| :set nocompatible viminfo+=nviminfo modeline |
| :edit " read modeline |
| /start of AUTO |
| =/end of AUTO |
| ENDTEST |
| |
| /* start of AUTO matically checked vim: set ts=4 : */ |
| { |
| if (test) |
| cmd1; |
| cmd2; |
| } |
| |
| { |
| if (test) |
| cmd1; |
| else |
| cmd2; |
| } |
| |
| { |
| if (test) |
| { |
| cmd1; |
| cmd2; |
| } |
| } |
| |
| { |
| if (test) |
| { |
| cmd1; |
| else |
| } |
| } |
| |
| { |
| while (this) |
| if (test) |
| cmd1; |
| cmd2; |
| } |
| |
| { |
| while (this) |
| if (test) |
| cmd1; |
| else |
| cmd2; |
| } |
| |
| { |
| if (test) |
| { |
| cmd; |
| } |
| |
| if (test) |
| cmd; |
| } |
| |
| { |
| if (test) { |
| cmd; |
| } |
| |
| if (test) cmd; |
| } |
| |
| { |
| cmd1; |
| for (blah) |
| while (this) |
| if (test) |
| cmd2; |
| cmd3; |
| } |
| |
| { |
| cmd1; |
| for (blah) |
| while (this) |
| if (test) |
| cmd2; |
| cmd3; |
| |
| if (test) |
| { |
| cmd1; |
| cmd2; |
| cmd3; |
| } |
| } |
| |
| |
| /* Test for 'cindent' do/while mixed with if/else: */ |
| |
| { |
| do |
| if (asdf) |
| asdfasd; |
| while (cond); |
| |
| do |
| if (asdf) |
| while (asdf) |
| asdf; |
| while (asdf); |
| } |
| |
| /* Test for 'cindent' with two ) on a continuation line */ |
| { |
| if (asdfasdf;asldkfj asdlkfj as;ldkfj sal;d |
| aal;sdkjf ( ;asldfkja;sldfk |
| al;sdjfka ;slkdf ) sa;ldkjfsa dlk;) |
| line up here; |
| } |
| |
| |
| /* C++ tests: */ |
| |
| // foo() these three lines should remain in column 0 |
| // { |
| // } |
| |
| /* Test for continuation and unterminated lines: */ |
| { |
| i = 99 + 14325 + |
| 21345 + |
| 21345 + |
| 21345 + ( 21345 + |
| 21345) + |
| 2345 + |
| 1234; |
| c = 1; |
| } |
| |
| /* |
| testje for indent with empty line |
| |
| here */ |
| |
| { |
| if (testing && |
| not a joke || |
| line up here) |
| hay; |
| if (testing && |
| (not a joke || testing |
| )line up here) |
| hay; |
| if (testing && |
| (not a joke || testing |
| line up here)) |
| hay; |
| } |
| |
| |
| { |
| switch (c) |
| { |
| case xx: |
| do |
| if (asdf) |
| do |
| asdfasdf; |
| while (asdf); |
| else |
| asdfasdf; |
| while (cond); |
| case yy: |
| case xx: |
| case zz: |
| testing; |
| } |
| } |
| |
| { |
| if (cond) { |
| foo; |
| } |
| else |
| { |
| bar; |
| } |
| } |
| |
| { |
| if (alskdfj ;alsdkfjal;skdjf (;sadlkfsa ;dlkf j;alksdfj ;alskdjf |
| alsdkfj (asldk;fj |
| awith cino=(0 ;lf this one goes to below the paren with == |
| ;laksjfd ;lsakdjf ;alskdf asd) |
| asdfasdf;))) |
| asdfasdf; |
| } |
| |
| int |
| func(a, b) |
| int a; |
| int c; |
| { |
| if (c1 && (c2 || |
| c3)) |
| foo; |
| if (c1 && |
| (c2 || c3) |
| ) |
| } |
| |
| { |
| while (asd) |
| { |
| if (asdf) |
| if (test) |
| if (that) |
| { |
| if (asdf) |
| do |
| cdasd; |
| while (as |
| df); |
| } |
| else |
| if (asdf) |
| asdf; |
| else |
| asdf; |
| asdf; |
| } |
| } |
| |
| { |
| s = "/*"; b = ';' |
| s = "/*"; b = ';'; |
| a = b; |
| } |
| |
| { |
| switch (a) |
| { |
| case a: |
| switch (t) |
| { |
| case 1: |
| cmd; |
| break; |
| case 2: |
| cmd; |
| break; |
| } |
| cmd; |
| break; |
| case b: |
| { |
| int i; |
| cmd; |
| } |
| break; |
| case c: { |
| int i; |
| cmd; |
| } |
| case d: if (cond && |
| test) { /* this line doesn't work right */ |
| int i; |
| cmd; |
| } |
| break; |
| } |
| } |
| |
| { |
| if (!(vim_strchr(p_cpo, CPO_BUFOPTGLOB) != NULL && entering) && |
| (bp_to->b_p_initialized || |
| (!entering && vim_strchr(p_cpo, CPO_BUFOPT) != NULL))) |
| return; |
| label : |
| asdf = asdf ? |
| asdf : asdf; |
| asdf = asdf ? |
| asdf: asdf; |
| } |
| |
| /* Special Comments : This function has the added complexity (compared */ |
| /* : to addtolist) of having to check for a detail */ |
| /* : texture and add that to the list first. */ |
| |
| char *(array[100]) = { |
| "testje", |
| "foo", |
| "bar", |
| } |
| |
| enum soppie |
| { |
| yes = 0, |
| no, |
| maybe |
| }; |
| |
| typedef enum soppie |
| { |
| yes = 0, |
| no, |
| maybe |
| }; |
| |
| static enum |
| { |
| yes = 0, |
| no, |
| maybe |
| } soppie; |
| |
| public static enum |
| { |
| yes = 0, |
| no, |
| maybe |
| } soppie; |
| |
| static private enum |
| { |
| yes = 0, |
| no, |
| maybe |
| } soppie; |
| |
| { |
| int a, |
| b; |
| } |
| |
| { |
| struct Type |
| { |
| int i; |
| char *str; |
| } var[] = |
| { |
| 0, "zero", |
| 1, "one", |
| 2, "two", |
| 3, "three" |
| }; |
| |
| float matrix[3][3] = |
| { |
| { |
| 0, |
| 1, |
| 2 |
| }, |
| { |
| 3, |
| 4, |
| 5 |
| }, |
| { |
| 6, |
| 7, |
| 8 |
| } |
| }; |
| } |
| |
| { |
| /* blah ( blah */ |
| /* where does this go? */ |
| |
| /* blah ( blah */ |
| cmd; |
| |
| func(arg1, |
| /* comment */ |
| arg2); |
| a; |
| { |
| b; |
| { |
| c; /* Hey, NOW it indents?! */ |
| } |
| } |
| |
| { |
| func(arg1, |
| arg2, |
| arg3); |
| /* Hey, what am I doing here? Is this coz of the ","? */ |
| } |
| } |
| |
| main () |
| { |
| if (cond) |
| { |
| a = b; |
| } |
| if (cond) { |
| a = c; |
| } |
| if (cond) |
| a = d; |
| return; |
| } |
| |
| { |
| case 2: if (asdf && |
| asdfasdf) |
| aasdf; |
| a = 9; |
| case 3: if (asdf) |
| aasdf; |
| a = 9; |
| case 4: x = 1; |
| y = 2; |
| |
| label: if (asdf) |
| here; |
| |
| label: if (asdf && |
| asdfasdf) |
| { |
| } |
| |
| label: if (asdf && |
| asdfasdf) { |
| there; |
| } |
| |
| label: if (asdf && |
| asdfasdf) |
| there; |
| } |
| |
| { |
| /* |
| hello with ":set comments= cino=c5" |
| */ |
| |
| /* |
| hello with ":set comments= cino=" |
| */ |
| } |
| |
| |
| { |
| if (a < b) { |
| a = a + 1; |
| } else |
| a = a + 2; |
| |
| if (a) |
| do { |
| testing; |
| } while (asdfasdf); |
| a = b + 1; |
| asdfasdf |
| } |
| |
| { |
| for ( int i = 0; |
| i < 10; i++ ) |
| { |
| } |
| i = 0; |
| } |
| |
| class bob |
| { |
| int foo() {return 1;} |
| int bar; |
| } |
| |
| main() |
| { |
| while(1) |
| if (foo) |
| { |
| bar; |
| } |
| else { |
| asdf; |
| } |
| misplacedline; |
| } |
| |
| { |
| if (clipboard.state == SELECT_DONE |
| && ((row == clipboard.start.lnum |
| && col >= clipboard.start.col) |
| || row > clipboard.start.lnum)) |
| } |
| |
| { |
| if (1) {i += 4;} |
| where_am_i; |
| return 0; |
| } |
| |
| { |
| { |
| } // sdf(asdf |
| if (asdf) |
| asd; |
| } |
| |
| { |
| label1: |
| label2: |
| } |
| |
| { |
| int fooRet = foo(pBar1, false /*fKB*/, |
| true /*fPTB*/, 3 /*nT*/, false /*fDF*/); |
| f() { |
| for ( i = 0; |
| i < m; |
| /* c */ i++ ) { |
| a = b; |
| } |
| } |
| } |
| |
| { |
| f1(/*comment*/); |
| f2(); |
| } |
| |
| { |
| do { |
| if (foo) { |
| } else |
| ; |
| } while (foo); |
| foo(); // was wrong |
| } |
| |
| int x; // no extra indent because of the ; |
| void func() |
| { |
| } |
| |
| char *tab[] = {"aaa", |
| "};", /* }; */ NULL} |
| int indented; |
| {} |
| |
| char *a[] = {"aaa", "bbb", |
| "ccc", NULL}; |
| // here |
| |
| char *tab[] = {"aaa", |
| "xx", /* xx */}; /* asdf */ |
| int not_indented; |
| |
| { |
| do { |
| switch (bla) |
| { |
| case 1: if (foo) |
| bar; |
| } |
| } while (boo); |
| wrong; |
| } |
| |
| int foo, |
| bar; |
| int foo; |
| |
| #if defined(foo) \ |
| && defined(bar) |
| char * xx = "asdf\ |
| foo\ |
| bor"; |
| int x; |
| |
| char *foo = "asdf\ |
| asdf\ |
| asdf", |
| *bar; |
| |
| void f() |
| { |
| #if defined(foo) \ |
| && defined(bar) |
| char *foo = "asdf\ |
| asdf\ |
| asdf", |
| *bar; |
| { |
| int i; |
| char *foo = "asdf\ |
| asdf\ |
| asdf", |
| *bar; |
| } |
| #endif |
| } |
| #endif |
| |
| int y; // comment |
| // comment |
| |
| // comment |
| |
| { |
| Constructor(int a, |
| int b ) : BaseClass(a) |
| { |
| } |
| } |
| |
| void foo() |
| { |
| char one, |
| two; |
| struct bla piet, |
| jan; |
| enum foo kees, |
| jannie; |
| static unsigned sdf, |
| krap; |
| unsigned int piet, |
| jan; |
| int |
| kees, |
| jan; |
| } |
| |
| { |
| t(int f, |
| int d); // ) |
| d(); |
| } |
| |
| Constructor::Constructor(int a, |
| int b |
| ) : |
| BaseClass(a, |
| b, |
| c), |
| mMember(b), |
| { |
| } |
| |
| Constructor::Constructor(int a, |
| int b ) : |
| BaseClass(a) |
| { |
| } |
| |
| Constructor::Constructor(int a, |
| int b ) /*x*/ : /*x*/ BaseClass(a), |
| member(b) |
| { |
| } |
| |
| class CAbc : |
| public BaseClass1, |
| protected BaseClass2 |
| { |
| int Test() { return FALSE; } |
| int Test1() { return TRUE; } |
| |
| CAbc(int a, int b ) : |
| BaseClass(a) |
| { |
| switch(xxx) |
| { |
| case abc: |
| asdf(); |
| break; |
| |
| case 999: |
| baer(); |
| break; |
| } |
| } |
| |
| public: // <-- this was incoreectly indented before!! |
| void testfall(); |
| protected: |
| void testfall(); |
| }; |
| |
| class CAbc : public BaseClass1, |
| protected BaseClass2 |
| { |
| }; |
| |
| static struct |
| { |
| int a; |
| int b; |
| } variable[COUNT] = |
| { |
| { |
| 123, |
| 456 |
| }, |
| { |
| 123, |
| 456 |
| } |
| }; |
| |
| static struct |
| { |
| int a; |
| int b; |
| } variable[COUNT] = |
| { |
| { 123, 456 }, |
| { 123, 456 } |
| }; |
| |
| void asdf() /* ind_maxparen may cause trouble here */ |
| { |
| if ((0 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1 |
| && 1)) break; |
| } |
| |
| foo() |
| { |
| a = cond ? foo() : asdf |
| + asdf; |
| |
| a = cond ? |
| foo() : asdf |
| + asdf; |
| } |
| |
| int main(void) |
| { |
| if (a) |
| if (b) |
| 2; |
| else 3; |
| next_line_of_code(); |
| } |
| |
| barry() |
| { |
| Foo::Foo (int one, |
| int two) |
| : something(4) |
| {} |
| } |
| |
| barry() |
| { |
| Foo::Foo (int one, int two) |
| : something(4) |
| {} |
| } |
| |
| Constructor::Constructor(int a, |
| int b |
| ) : |
| BaseClass(a, |
| b, |
| c), |
| mMember(b) |
| { |
| } |
| int main () |
| { |
| if (lala) |
| do |
| ++(*lolo); |
| while (lili |
| && lele); |
| lulu; |
| } |
| |
| int main () |
| { |
| switch (c) |
| { |
| case 'c': if (cond) |
| { |
| } |
| } |
| } |
| |
| main() |
| { |
| (void) MyFancyFuasdfadsfnction( |
| argument); |
| } |
| |
| main() |
| { |
| char foo[] = "/*"; |
| /* as |
| df */ |
| hello |
| } |
| |
| /* valid namespaces with normal indent */ |
| namespace |
| { |
| { |
| 111111111111; |
| } |
| } |
| namespace /* test */ |
| { |
| 11111111111111111; |
| } |
| namespace // test |
| { |
| 111111111111111111; |
| } |
| namespace |
| { |
| 111111111111111111; |
| } |
| namespace test |
| { |
| 111111111111111111; |
| } |
| namespace{ |
| 111111111111111111; |
| } |
| namespace test{ |
| 111111111111111111; |
| } |
| namespace { |
| 111111111111111111; |
| } |
| namespace test { |
| 111111111111111111; |
| namespace test2 { |
| 22222222222222222; |
| } |
| } |
| |
| /* invalid namespaces use block indent */ |
| namespace test test2 { |
| 111111111111111111111; |
| } |
| namespace11111111111 { |
| 111111111111; |
| } |
| namespace() { |
| 1111111111111; |
| } |
| namespace() |
| { |
| 111111111111111111; |
| } |
| namespace test test2 |
| { |
| 1111111111111111111; |
| } |
| namespace111111111 |
| { |
| 111111111111111111; |
| } |
| |
| /* end of AUTO */ |
| |
| STARTTEST |
| :set tw=0 wm=60 columns=80 noai fo=croq |
| /serious/e |
| a about life, the universe, and the rest |
| ENDTEST |
| |
| { |
| |
| /* this is |
| * a real serious important big |
| * comment |
| */ |
| /* insert " about life, the universe, and the rest" after "serious" */ |
| } |
| |
| STARTTEST |
| :set nocin |
| /comments |
| joabout life/happens |
| jothere/below |
| oline/this |
| Ohello |
| ENDTEST |
| |
| { |
| /* |
| * Testing for comments, without 'cin' set |
| */ |
| |
| /* |
| * what happens here? |
| */ |
| |
| /* |
| the end of the comment, try inserting a line below */ |
| |
| /* how about |
| this one */ |
| } |
| |
| STARTTEST |
| :set cin |
| /vec2 |
| == |
| ENDTEST |
| |
| { |
| var = this + that + vec[0] * vec[0] |
| + vec[1] * vec[1] |
| + vec2[2] * vec[2]; |
| } |
| |
| STARTTEST |
| :set cin |
| :set cino=}4 |
| /testing1 |
| k2==/testing2 |
| k2== |
| ENDTEST |
| |
| { |
| asdf asdflkajds f; |
| if (tes & ting) { |
| asdf asdf asdf ; |
| asdfa sdf asdf; |
| } |
| testing1; |
| if (tes & ting) |
| { |
| asdf asdf asdf ; |
| asdfa sdf asdf; |
| } |
| testing2; |
| } |
| |
| STARTTEST |
| :set cin |
| :set cino=(0,)20 |
| /main |
| =][ |
| ENDTEST |
| |
| main ( int first_par, /* |
| * Comment for |
| * first par |
| */ |
| int second_par /* |
| * Comment for |
| * second par |
| */ |
| ) |
| { |
| func( first_par, /* |
| * Comment for |
| * first par |
| */ |
| second_par /* |
| * Comment for |
| * second par |
| */ |
| ); |
| |
| } |
| |
| STARTTEST |
| :set cin |
| :set cino=es,n0s |
| /main |
| =][ |
| ENDTEST |
| |
| main(void) |
| { |
| /* Make sure that cino=X0s is not parsed like cino=Xs. */ |
| if (cond) |
| foo(); |
| else |
| { |
| bar(); |
| } |
| } |
| |
| STARTTEST |
| :set cin |
| :set cino= |
| ]]=][ |
| ENDTEST |
| |
| { |
| do |
| { |
| if () |
| { |
| if () |
| asdf; |
| else |
| asdf; |
| } |
| } while (); |
| cmd; /* this should go under the } */ |
| } |
| |
| STARTTEST |
| ]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| if ( k() ) { |
| l(); |
| |
| } else { /* Start (two words) end */ |
| m(); |
| } |
| |
| n(); |
| } |
| |
| STARTTEST |
| :set cino={s,e-s |
| ]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| if ( k() ) |
| { |
| l(); |
| } else { /* Start (two words) end */ |
| m(); |
| } |
| n(); /* should be under the if () */ |
| } |
| |
| STARTTEST |
| :set cino={s,fs |
| ]]=/ foo |
| ENDTEST |
| |
| void bar(void) |
| { |
| static array[2][2] = |
| { |
| { 1, 2 }, |
| { 3, 4 }, |
| } |
| |
| while (a) |
| { |
| foo(&a); |
| } |
| |
| { |
| int a; |
| { |
| a = a + 1; |
| } |
| } |
| b = a; |
| } |
| |
| void func(void) |
| { |
| a = 1; |
| { |
| b = 2; |
| } |
| c = 3; |
| d = 4; |
| } |
| /* foo */ |
| |
| STARTTEST |
| :set cino= |
| /while |
| ohere |
| ENDTEST |
| |
| a() |
| { |
| do { |
| a = a + |
| a; |
| } while ( a ); /* add text under this line */ |
| if ( a ) |
| a; |
| } |
| |
| STARTTEST |
| :set cino= com= |
| /comment |
| olabel2: b();
label3 /* post */:
/* pre */ label4:
f(/*com*/);
if (/*com*/)
cmd(); |
| ENDTEST |
| |
| a() |
| { |
| label1: |
| /* hmm */ |
| // comment |
| } |
| |
| STARTTEST |
| :set comments& comments^=s:/*,m:**,ex:*/ |
| /simple |
| =5j |
| ENDTEST |
| |
| /* |
| * A simple comment |
| */ |
| |
| /* |
| ** A different comment |
| */ |
| |
| STARTTEST |
| :set cino=c0 |
| :set comments& comments-=s1:/* comments^=s0:/* |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| |
| /********* |
| A comment. |
| *********/ |
| } |
| |
| STARTTEST |
| :set cino=c0,C1 |
| :set comments& comments-=s1:/* comments^=s0:/* |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| |
| /********* |
| A comment. |
| *********/ |
| } |
| |
| STARTTEST |
| :set cino= |
| ]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| c = c1 && |
| ( |
| c2 || |
| c3 |
| ) && c4; |
| } |
| |
| STARTTEST |
| :set cino=(s |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| c = c1 && |
| ( |
| c2 || |
| c3 |
| ) && c4; |
| } |
| |
| STARTTEST |
| :set cino=(s,U1 |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| c = c1 && |
| ( |
| c2 || |
| c3 |
| ) && c4; |
| } |
| |
| STARTTEST |
| :set cino=(0 |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| if ( c1 |
| && ( c2 |
| || c3)) |
| foo; |
| } |
| |
| STARTTEST |
| :set cino=(0,w1 |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| if ( c1 |
| && ( c2 |
| || c3)) |
| foo; |
| } |
| |
| STARTTEST |
| :set cino=(s |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| c = c1 && ( |
| c2 || |
| c3 |
| ) && c4; |
| if ( |
| c1 && c2 |
| ) |
| foo; |
| } |
| |
| STARTTEST |
| :set cino=(s,m1 |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| c = c1 && ( |
| c2 || |
| c3 |
| ) && c4; |
| if ( |
| c1 && c2 |
| ) |
| foo; |
| } |
| |
| STARTTEST |
| :set cino=b1 |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| switch (x) |
| { |
| case 1: |
| a = b; |
| break; |
| default: |
| a = 0; |
| break; |
| } |
| } |
| |
| STARTTEST |
| :set cino=(0,W5 |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| invokeme( |
| argu, |
| ment); |
| invokeme( |
| argu, |
| ment |
| ); |
| invokeme(argu, |
| ment |
| ); |
| } |
| |
| STARTTEST |
| :set cino=/6 |
| 2kdd]]=][ |
| ENDTEST |
| |
| void f() |
| { |
| statement; |
| // comment 1 |
| // comment 2 |
| } |
| |
| STARTTEST |
| :set cino= |
| 2kdd]]/comment 1/+1 |
| == |
| ENDTEST |
| |
| void f() |
| { |
| statement; |
| // comment 1 |
| // comment 2 |
| } |
| |
| STARTTEST |
| :set cino=g0 |
| 2kdd]]=][ |
| ENDTEST |
| |
| class CAbc |
| { |
| int Test() { return FALSE; } |
| |
| public: // comment |
| void testfall(); |
| protected: |
| void testfall(); |
| }; |
| |
| STARTTEST |
| :set cino=(0,gs,hs |
| 2kdd]]=][ |
| ENDTEST |
| |
| class Foo : public Bar |
| { |
| public: |
| virtual void method1(void) = 0; |
| virtual void method2(int arg1, |
| int arg2, |
| int arg3) = 0; |
| }; |
| |
| STARTTEST |
| :set cino=+20 |
| 2kdd]]=][ |
| ENDTEST |
| |
| void |
| foo() |
| { |
| if (a) |
| { |
| } else |
| asdf; |
| } |
| |
| STARTTEST |
| :set cino=(0,W2s |
| 2kdd]]=][ |
| ENDTEST |
| |
| { |
| averylongfunctionnamelongfunctionnameaverylongfunctionname()->asd( |
| asdasdf, |
| func(asdf, |
| asdfadsf), |
| asdfasdf |
| ); |
| |
| /* those are ugly, but consequent */ |
| |
| func()->asd(asdasdf, |
| averylongfunctionname( |
| abc, |
| dec)->averylongfunctionname( |
| asdfadsf, |
| asdfasdf, |
| asdfasdf, |
| ), |
| func(asdfadf, |
| asdfasdf |
| ), |
| asdasdf |
| ); |
| |
| averylongfunctionnameaverylongfunctionnameavery()->asd(fasdf( |
| abc, |
| dec)->asdfasdfasdf( |
| asdfadsf, |
| asdfasdf, |
| asdfasdf, |
| ), |
| func(asdfadf, |
| asdfasdf), |
| asdasdf |
| ); |
| } |
| |
| STARTTEST |
| :set cino=M1 |
| 2kdd]]=][ |
| ENDTEST |
| |
| int main () |
| { |
| if (cond1 && |
| cond2 |
| ) |
| foo; |
| } |
| |
| STARTTEST |
| :set cino=(0,ts |
| 2kdd2j=][ |
| ENDTEST |
| |
| void func(int a |
| #if defined(FOO) |
| , int b |
| , int c |
| #endif |
| ) |
| { |
| } |
| |
| STARTTEST |
| :set cino=(0 |
| 2kdd2j=][ |
| ENDTEST |
| |
| void |
| func(int a |
| #if defined(FOO) |
| , int b |
| , int c |
| #endif |
| ) |
| { |
| } |
| |
| STARTTEST |
| :set cino& |
| 2kdd2j=7][ |
| ENDTEST |
| |
| void func(void) |
| { |
| if(x==y) |
| if(y==z) |
| foo=1; |
| else { bar=1; |
| baz=2; |
| } |
| printf("Foo!\n"); |
| } |
| |
| void func1(void) |
| { |
| char* tab[] = {"foo", "bar", |
| "baz", "quux", |
| "this line used", "to be indented incorrectly"}; |
| foo(); |
| } |
| |
| void func2(void) |
| { |
| int tab[] = |
| {1, 2, |
| 3, 4, |
| 5, 6}; |
| |
| printf("This line used to be indented incorrectly.\n"); |
| } |
| |
| int foo[] |
| #ifdef BAR |
| |
| = { 1, 2, 3, |
| 4, 5, 6 } |
| |
| #endif |
| ; |
| int baz; |
| |
| void func3(void) |
| { |
| int tab[] = { |
| 1, 2, |
| 3, 4, |
| 5, 6}; |
| |
| printf("Don't you dare indent this line incorrectly!\n"); |
| } |
| |
| void |
| func4(a, b, |
| c) |
| int a; |
| int b; |
| int c; |
| { |
| } |
| |
| void |
| func5( |
| int a, |
| int b) |
| { |
| } |
| |
| void |
| func6( |
| int a) |
| { |
| } |
| |
| STARTTEST |
| :set cino& |
| :set cino+=l1 |
| 2kdd2j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| int tab[] = |
| { |
| 1, 2, 3, |
| 4, 5, 6}; |
| |
| printf("Indent this line correctly!\n"); |
| |
| switch (foo) |
| { |
| case bar: |
| printf("bar"); |
| break; |
| case baz: { |
| printf("baz"); |
| break; |
| } |
| case quux: |
| printf("But don't break the indentation of this instruction\n"); |
| break; |
| } |
| } |
| |
| STARTTEST |
| :set cino& |
| 2kdd2j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| cout << "a" |
| << "b" |
| << ") :" |
| << "c"; |
| } |
| |
| STARTTEST |
| :set com=s1:/*,m:*,ex:*/ |
| ]]3jofoo(); |
| ENDTEST |
| |
| void func(void) |
| { |
| /* |
| * This is a comment. |
| */ |
| } |
| |
| STARTTEST |
| :set cino& |
| 2kdd2j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| for (int i = 0; i < 10; ++i) |
| if (i & 1) { |
| foo(1); |
| } else |
| foo(0); |
| baz(); |
| } |
| |
| STARTTEST |
| :set cino=k2s,(0 |
| 2kdd3j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| if (condition1 |
| && condition2) |
| action(); |
| function(argument1 |
| && argument2); |
| |
| if (c1 && (c2 || |
| c3)) |
| foo; |
| if (c1 && |
| (c2 || c3)) |
| { |
| } |
| |
| if ( c1 |
| && ( c2 |
| || c3)) |
| foo; |
| func( c1 |
| && ( c2 |
| || c3)) |
| foo; |
| } |
| |
| STARTTEST |
| :set cino=k2s,(s |
| 2kdd3j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| if (condition1 |
| && condition2) |
| action(); |
| function(argument1 |
| && argument2); |
| |
| if (c1 && (c2 || |
| c3)) |
| foo; |
| if (c1 && |
| (c2 || c3)) |
| { |
| } |
| |
| if ( c1 |
| && ( c2 |
| || c3)) |
| foo; |
| func( c1 |
| && ( c2 |
| || c3)) |
| foo; |
| } |
| |
| STARTTEST |
| :set cino=k2s,(s,U1 |
| 2kdd3j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| if (condition1 |
| && condition2) |
| action(); |
| function(argument1 |
| && argument2); |
| |
| if (c1 && (c2 || |
| c3)) |
| foo; |
| if (c1 && |
| (c2 || c3)) |
| { |
| } |
| if (c123456789 |
| && (c22345 |
| || c3)) |
| printf("foo\n"); |
| |
| c = c1 && |
| ( |
| c2 || |
| c3 |
| ) && c4; |
| } |
| |
| STARTTEST |
| :set cino=k2s,(0,W4 |
| 2kdd3j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| if (condition1 |
| && condition2) |
| action(); |
| function(argument1 |
| && argument2); |
| |
| if (c1 && (c2 || |
| c3)) |
| foo; |
| if (c1 && |
| (c2 || c3)) |
| { |
| } |
| if (c123456789 |
| && (c22345 |
| || c3)) |
| printf("foo\n"); |
| |
| if ( c1 |
| && ( c2 |
| || c3)) |
| foo; |
| |
| a_long_line( |
| argument, |
| argument); |
| a_short_line(argument, |
| argument); |
| } |
| |
| STARTTEST |
| :set cino=k2s,u2 |
| 2kdd3j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| if (condition1 |
| && condition2) |
| action(); |
| function(argument1 |
| && argument2); |
| |
| if (c1 && (c2 || |
| c3)) |
| foo; |
| if (c1 && |
| (c2 || c3)) |
| { |
| } |
| if (c123456789 |
| && (c22345 |
| || c3)) |
| printf("foo\n"); |
| } |
| |
| STARTTEST |
| :set cino=k2s,(0,w1 |
| 2kdd3j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| if (condition1 |
| && condition2) |
| action(); |
| function(argument1 |
| && argument2); |
| |
| if (c1 && (c2 || |
| c3)) |
| foo; |
| if (c1 && |
| (c2 || c3)) |
| { |
| } |
| if (c123456789 |
| && (c22345 |
| || c3)) |
| printf("foo\n"); |
| |
| if ( c1 |
| && ( c2 |
| || c3)) |
| foo; |
| func( c1 |
| && ( c2 |
| || c3)) |
| foo; |
| } |
| |
| STARTTEST |
| :set cino=k2,(s |
| 2kdd3j=][ |
| ENDTEST |
| |
| void func(void) |
| { |
| if (condition1 |
| && condition2) |
| action(); |
| function(argument1 |
| && argument2); |
| |
| if (c1 && (c2 || |
| c3)) |
| foo; |
| if (c1 && |
| (c2 || c3)) |
| { |
| } |
| } |
| |
| STARTTEST |
| :set cino=N-s |
| /^NAMESPACESTART |
| =/^NAMESPACEEND |
| ENDTEST |
| |
| NAMESPACESTART |
| /* valid namespaces with normal indent */ |
| namespace |
| { |
| { |
| 111111111111; |
| } |
| } |
| namespace /* test */ |
| { |
| 11111111111111111; |
| } |
| namespace // test |
| { |
| 111111111111111111; |
| } |
| namespace |
| { |
| 111111111111111111; |
| } |
| namespace test |
| { |
| 111111111111111111; |
| } |
| namespace{ |
| 111111111111111111; |
| } |
| namespace test{ |
| 111111111111111111; |
| } |
| namespace { |
| 111111111111111111; |
| } |
| namespace test { |
| 111111111111111111; |
| namespace test2 { |
| 22222222222222222; |
| } |
| } |
| |
| /* invalid namespaces use block indent */ |
| namespace test test2 { |
| 111111111111111111111; |
| } |
| namespace11111111111 { |
| 111111111111; |
| } |
| namespace() { |
| 1111111111111; |
| } |
| namespace() |
| { |
| 111111111111111111; |
| } |
| namespace test test2 |
| { |
| 1111111111111111111; |
| } |
| namespace111111111 |
| { |
| 111111111111111111; |
| } |
| NAMESPACEEND |
| |
| |
| STARTTEST |
| :set cino=j1,J1 |
| /^JSSTART |
| =/^JSEND |
| ENDTEST |
| |
| JSSTART |
| var bar = { |
| foo: { |
| that: this, |
| some: ok, |
| }, |
| "bar":{ |
| a : 2, |
| b: "123abc", |
| x: 4, |
| "y": 5 |
| } |
| } |
| JSEND |
| |
| STARTTEST |
| :set cino=j1,J1 |
| /^JSSTART |
| =/^JSEND |
| ENDTEST |
| |
| JSSTART |
| var foo = [ |
| 1, |
| 2, |
| 3 |
| ]; |
| JSEND |
| |
| STARTTEST |
| :set cino=j1,J1 |
| /^JSSTART |
| =/^JSEND |
| ENDTEST |
| |
| JSSTART |
| function bar() { |
| var foo = [ |
| 1, |
| 2, |
| 3 |
| ]; |
| } |
| JSEND |
| |
| STARTTEST |
| :set cino=j1,J1 |
| /^JSSTART |
| =/^JSEND |
| ENDTEST |
| |
| JSSTART |
| (function($){ |
| |
| if (cond && |
| cond) { |
| stmt; |
| } |
| window.something.left = |
| (width - 50 + offset) + "px"; |
| var class_name='myclass'; |
| |
| function private_method() { |
| } |
| |
| var public_method={ |
| method: function(options,args){ |
| private_method(); |
| } |
| } |
| |
| function init(options) { |
| |
| $(this).data(class_name+'_public',$.extend({},{ |
| foo: 'bar', |
| bar: 2, |
| foobar: [ |
| 1, |
| 2, |
| 3 |
| ], |
| callback: function(){ |
| return true; |
| } |
| }, options||{})); |
| } |
| |
| $.fn[class_name]=function() { |
| |
| var _arguments=arguments; |
| return this.each(function(){ |
| |
| var options=$(this).data(class_name+'_public'); |
| if (!options) { |
| init.apply(this,_arguments); |
| |
| } else { |
| var method=public_method[_arguments[0]]; |
| |
| if (typeof(method)!='function') { |
| console.log(class_name+' has no method "'+_arguments[0]+'"'); |
| return false; |
| } |
| _arguments[0]=options; |
| method.apply(this,_arguments); |
| } |
| }); |
| } |
| |
| })(jQuery); |
| JSEND |
| |
| STARTTEST |
| :set cino=j1,J1 |
| /^JSSTART |
| =/^JSEND |
| ENDTEST |
| |
| JSSTART |
| function init(options) { |
| $(this).data(class_name+'_public',$.extend({},{ |
| foo: 'bar', |
| bar: 2, |
| foobar: [ |
| 1, |
| 2, |
| 3 |
| ], |
| callback: function(){ |
| return true; |
| } |
| }, options||{})); |
| } |
| JSEND |
| |
| STARTTEST |
| :set cino=j1,J1 |
| /^JSSTART |
| =/^JSEND |
| ENDTEST |
| |
| JSSTART |
| (function($){ |
| function init(options) { |
| $(this).data(class_name+'_public',$.extend({},{ |
| foo: 'bar', |
| bar: 2, |
| foobar: [ |
| 1, |
| 2, |
| 3 |
| ], |
| callback: function(){ |
| return true; |
| } |
| }, options||{})); |
| } |
| })(jQuery); |
| JSEND |
| |
| STARTTEST |
| :set cino=j1,J1,+2 |
| /^JSSTART |
| =/^JSEND |
| ENDTEST |
| |
| JSSTART |
| // Results of JavaScript indent |
| // 1 |
| (function(){ |
| var a = [ |
| 'a', |
| 'b', |
| 'c', |
| 'd', |
| 'e', |
| 'f', |
| 'g', |
| 'h', |
| 'i' |
| ]; |
| }()) |
| |
| // 2 |
| (function(){ |
| var a = [ |
| 0 + |
| 5 * |
| 9 * |
| 'a', |
| 'b', |
| 0 + |
| 5 * |
| 9 * |
| 'c', |
| 'd', |
| 'e', |
| 'f', |
| 'g', |
| 'h', |
| 'i' |
| ]; |
| }()) |
| |
| // 3 |
| (function(){ |
| var a = [ |
| 0 + |
| // comment 1 |
| 5 * |
| /* comment 2 */ |
| 9 * |
| 'a', |
| 'b', |
| 0 + |
| 5 * |
| 9 * |
| 'c', |
| 'd', |
| 'e', |
| 'f', |
| 'g', |
| 'h', |
| 'i' |
| ]; |
| }()) |
| |
| // 4 |
| { |
| var a = [ |
| 0, |
| 1 |
| ]; |
| var b; |
| var c; |
| } |
| |
| // 5 |
| { |
| var a = [ |
| [ |
| 0 |
| ], |
| 2, |
| 3 |
| ]; |
| } |
| |
| // 6 |
| { |
| var a = [ |
| [ |
| 0, |
| 1 |
| ], |
| 2, |
| 3 |
| ]; |
| } |
| |
| // 7 |
| { |
| var a = [ |
| // [ |
| 0, |
| // 1 |
| // ], |
| 2, |
| 3 |
| ]; |
| } |
| |
| // 8 |
| var x = [ |
| (function(){ |
| var a, |
| b, |
| c, |
| d, |
| e, |
| f, |
| g, |
| h, |
| i; |
| }) |
| ]; |
| |
| // 9 |
| var a = [ |
| 0 + |
| 5 * |
| 9 * |
| 'a', |
| 'b', |
| 0 + |
| 5 * |
| 9 * |
| 'c', |
| 'd', |
| 'e', |
| 'f', |
| 'g', |
| 'h', |
| 'i' |
| ]; |
| |
| // 10 |
| var a, |
| b, |
| c, |
| d, |
| e, |
| f, |
| g, |
| h, |
| i; |
| JSEND |
| |
| STARTTEST |
| :g/^STARTTEST/.,/^ENDTEST/d |
| :1;/start of AUTO/,$wq! test.out |
| ENDTEST |
