thac0/vim
1
0
Fork 0
forked from aniani/vim
Code Activity
Files
6119e6156e024d9047bbfeb7cdfdae259f9e1b92
vim/src/testdir/test3.in
Bram Moolenaar e01f4f86ce patch 7.4.912 
Problem:    Wrong indenting for C++ constructor.
Solution:   Recognize ::.  (Anhong)
2015-11-10 14:06:53 +01:00

2304 lines
22 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* 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)
{
}
A::A(int a, int b)
: aa(a),
bb(b),
cc(c)
{
}
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;
}
void getstring() {
/* Raw strings */
const char* s = R"(
test {
# comment
field: 123
}
)";
}
void getstring() {
const char* s = R"foo(
test {
# comment
field: 123
}
)foo";
}
{
int a[4] = {
[0] = 0,
[1] = 1,
[2] = 2,
[3] = 3,
};
}
{
a = b[2]
+ 3;
}
{
if (1)
/* aaaaa
* bbbbb
*/
a = 1;
}
void func()
{
switch (foo)
{
case (bar):
if (baz())
quux();
break;
case (shmoo):
if (!bar)
{
}
case (foo1):
switch (bar)
{
case baz:
baz_f();
break;
}
break;
default:
baz();
baz();
break;
}
}
/* 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
View Git Blame Copy Permalink