Cpp

Bracket

Bracket style

Allman/bsd/break

A1

int Foo(bool isFoo)
{
     if (isFoo)
     {
          bar();
          return 1;
     }
     else
          return 0;
}

Java/attach

A2

int Foo(bool isFoo) {
     if (isFoo) {
          bar();
          return 1;
     } else
          return 0;
}

A3

int Foo(bool isFoo)
{
     if (isFoo) {
          bar();
          return 1;
     } else
          return 0;
}

Stroustrup

A4

int Foo(bool isFoo)
{
     if (isFoo) {
          bar();
          return 1;
     } else
          return 0;
}

Whitesmith

A5

int Foo(bool isFoo)
     {
     if (isFoo)
          {
          bar();
          return 1;
          }
     else
          return 0;
     }

Banner/ratliff

A6

int Foo(bool isFoo) {
     if (isFoo) {
          bar();
          return 1;
          }
     else
          return 0;
     }

GNU

A7

int Foo(bool isFoo)
{
   if (isFoo)
      {
         bar();
         return 1;
      }
   else
      return 0;
}

Linux/knf

A8

int Foo(bool isFoo)
{
         if (isFoo) {
                   bar();
                   return 1;
         } else
                   return 0;
}

Horstmann/runin

A9

int Foo(bool isFoo)
{  if (isFoo)
    {   bar();
         return 1;
    }
    else
         return 0;
}

1tbs/otbs

A10

int Foo(bool isFoo)
{
     if (isFoo) {
          bar();
          return 1;
     } else {
          return 0;
     }
}

Pico

A11

int Foo(bool isFoo)
{  if (isFoo)
    {   bar();
         return 1; }
    else
         return 0; }

Lisp/python

A12

int Foo(bool isFoo) {
   if (isFoo) {
        bar();
         return 1; }
    else
         return 0; }

Google

A14

int Foo(bool isFoo) {
     if (isFoo) {
          bar();
          return 1;
     } else
          return 0;
}

VTK

A15

int Foo(bool isFoo)
{
     if (isFoo)
          {
          bar();
          return 1;
          }
     else
          return 0;
}

Mozilla

A16

int Foo(bool isBar)
{
    if (isBar) {
        bar();
        return 1;
    } else
        return 0;
}

None

Bracket Modify

Attach namespaces

Yes
xn
```
namespace FooName {
...
}
```
No
```
namespace FooName
{
...
}
```

Attach classes

Yes

xc

class Foo {
    public:
        Foo() {
            isFoo();
        }
};

class Foo
{
    public:
        Foo() {
            isFoo();
        }
};

Attach inlines

Yes

xl

class Foo
{
    public:
        Foo() {
            isFoo();
        }
};

class Foo
{
    public:
        Foo()
        {
            isFoo();
        }
};

Attach extern c

Yes
xk
```
#ifdef __cplusplus
extern "C" {
#endif
```
No
```
#ifdef __cplusplus
extern "C"
{
#endif
```

Attach closing while

Yes

xV

do
{
    bar();
    ++x;
} while x == 1;

do
{
    bar();
    ++x;
}
while x == 1;

Indentation

Indent using

Spaces

s

int*Foo(bool*isBar)
{
****if*(isBar)*{
********bar();
****}
****else*{
********bar(arg1,
************arg2,
************arg3);
****}
}

Tab

t

int*Foo(bool*isBar)
{
--->if*(isBar)*{
--->--->bar();
--->}
--->else*{
--->--->bar(arg1,
--->--->****arg2,
--->--->****arg3);
--->}
}

Force tab

T

int*Foo(bool*isBar)
{
--->if*(isBar)*{
--->--->bar();
--->}
--->else*{
--->--->bar(arg1,
--->--->--->arg2,
--->--->--->arg3);
--->}
}

Indent number

Range : 2-20

*Attach to previous short

//indent_number4
int Foo(bool isBar)
{
    bar();
}

//indent_number5
int Foo(bool isBar)
{
     bar();
}

Indent classes

Yes

C

class Foo
{
    public:
        Foo();
        virtual ~Foo();
};

class Foo
{
public:
    Foo();
    virtual ~Foo();
};

Indent modifiers

Yes

xG

class Foo
{
  public:
    Foo();
    virtual ~Foo();
};

class Foo
{
public:
    Foo();
    virtual ~Foo();
};

Indent switches

Yes

S

switch (foo)
{
    case 1:
        a += 1;
        break;

    case 2:
    {
        a += 2;
        break;
    }
}

switch (foo)
{
case 1:
    a += 1;
    break;

case 2:
{
    a += 2;
    break;
}
}

Indent cases

Yes

K

switch (foo)
{
    case 1:
        a += 1;
        break;

    case 2:
        {
            a += 2;
            break;
        }
}

switch (foo)
{
    case 1:
        a += 1;
        break;

    case 2:
    {
        a += 2;
        break;
    }
}

Indent namespaces

Yes

N

namespace foospace
{
    class Foo
    {
        public:
            Foo();
            virtual ~Foo();
    };
}

namespace foospace
{
class Foo
{
    public:
        Foo();
        virtual ~Foo();
};
}

Indent after parens

Yes

xU

void Foo(bool bar1,
    bool bar2)
{
    isLongFunction(bar1,
        bar2);

    isLongVariable = foo1
        || foo2;
}

void Foo(bool bar1,
         bool bar2)
{
    isLongFunction(bar1,
                   bar2);

    isLongVariable = foo1
                     || foo2;
}

Indent continuation

Range : 0-4

xt

isLongVariable =
    foo1 ||
    foo2;

isLongFunction(
    bar1,
    bar2);
becomes (with indent-continuation=3):

isLongVariable =
            foo1 ||
            foo2;

isLongFunction(
            bar1,
            bar2);

Indent labels

Yes

L

void Foo() {
    while (isFoo) {
        if (isFoo)
            goto error;
        ...
    error:
        ...
    }
}

void Foo() {
    while (isFoo) {
        if (isFoo)
            goto error;
        ...
error:
        ...
    }
}

Indent preproc block

Yes

xW

#ifdef _WIN32
    #include <windows.h>
    #ifndef NO_EXPORT
        #define EXPORT
    #endif
#endif

#ifdef _WIN32
#include <windows.h>
#ifndef NO_EXPORT
#define EXPORT
#endif
#endif

Indent preproc define

Yes

w

#define Is_Foo(arg,op)  \
    ((arg).compare(op)==0)

#define Is_Bar(arg,a,b)  \
    (Is_Foo((arg), (a))  \
        || Is_Foo((arg), (b)))

#define Is_Foo(arg,op)  \
((arg).compare(op)==0)

#define Is_Bar(arg,a,b)  \
(Is_Foo((arg), (a))   \
|| Is_Foo((arg), (b)))

Indent preproc cond

Yes

xw

isFoo = true;
          #ifdef UNICODE
          text = wideBuff;
          #else
          text = buff;
          #endif;

isFoo = true;
#ifdef UNICODE
          text = wideBuff;
#else
          text = buff;
#endif;

Indent col1 comments

Yes

Y

void Foo()
{
    // comment
    if (isFoo)
        bar();
}

void Foo()
{
// comment
    if (isFoo)
        bar();
}

Min conditional indent

0 indent

m0

if (a < b
    || c > d)
    foo++;

if (a < b
    || c > d)
{
    foo++;
}

1 indent

m1

if (a < b
    || c > d)
    foo++;

if (a < b
    || c > d)
{
    foo++;
}

2 indents

m2

if (a < b
        || c > d)
    foo++;

if (a < b
        || c > d)
{
    foo++;
}

0.5 indent

m3

if (a < b
    || c > d)
    foo++;

if (a < b
    || c > d)
{
    foo++;
}

Max continuation indent

Range : 40-120

M

fooArray[] = { red,
         green,
         blue };

fooFunction(barArg1,
         barArg2,
         barArg3);

becomes (with larger value)

fooArray[] = { red,
               green,
               blue };

fooFunction(barArg1,
            barArg2,
            barArg3);

Padding

Break blocks

Yes

f

isFoo = true;

if (isFoo) {
    bar();
} else {
    anotherBar();
}

isBar = false;

isFoo = true;
if (isFoo) {
    bar();
} else {
    anotherBar();
}
isBar = false;

Break all blocks

Yes

F

isFoo = true;

if (isFoo) {
    bar();

} else {
    anotherBar();
}

isBar = false;

isFoo = true;
if (isFoo) {
    bar();
} else {
    anotherBar();
}
isBar = false;

Pad operators

Yes

p

if (foo == 2)
     a = bar((b - c) * a, d--);

No
```
if (foo==2)
    a=bar((b-c)*a,d--);
```

Pad comma

Yes
xg
```
if (isFoo(a, b)
    bar(a, b);
```
No
```
if (isFoo(a,b)
    bar(a,b);
```

Pad parens

Yes
P
```
if ( isFoo ( a, b ) )
    bar ( a, b );
```
No
```
if (isFoo(a, b))
    bar(a, b);
```

Pad parens out

Yes
d
```
if (isFoo (a, b) )
    bar (a, b);
```
No
```
if (isFoo(a, b))
    bar(a, b);
```

Pad parens in

Yes
D
```
if ( isFoo( a, b ) )
    bar( a, b );
```
No
```
if (isFoo(a, b))
    bar(a, b);
```

Pad first paren out

Yes
xd
```
if (isFoo ((a+2), b))
    bar (a, b);
```
No
```
if (isFoo((a+2), b))
    bar(a, b);
```

Pad header

Yes
H
```
if (isFoo(a, b))
    bar(a, b);
```
No
```
if(isFoo(a, b))
    bar(a, b);
```

Unpad parens

Yes
U
```
if(isFoo(a, b))
    bar(a, b);
```
No
```
if ( isFoo( a, b ) )
    bar ( a, b );
```

Delete empty lines

Yes

xe

void Foo()
{
    foo1 = 1;
    foo2 = 2;
}

void Foo()
{

    foo1 = 1;

    foo2 = 2;

}

Fill empty lines

Yes

E

void Foo(bool isFoo) {
****if (isFoo) {
********bar();
****}
****
****else {
********anotherBar();
****}
}

void Foo(bool isFoo) {
****if (isFoo) {
********bar();
****}

****else {
********anotherBar();
****}
}

Align pointer

None

char *foo1;
char& foo2;

//remains unchanged.

Type
k1
```
char* foo1;
char& foo2;
```
Middle
k2
```
char * foo1;
char & foo2;
```
Name
k3
```
char *foo1;
char &foo2;
```

Align reference

Same
```
char &foo1;

//same as pointer.
```
None
W0
```
char &foo1;

//remains unchanged.
```
Type
W1
```
char& foo1;
```
Middle
W2
```
char & foo1;
```
Name
W3
```
char &foo1;
```

Formatting

Break closing braces

Yes

y

void Foo(bool isFoo) {
    if (isFoo) {
        bar();
    }
    else {
        anotherBar();
    }
}

void Foo(bool isFoo) {
    if (isFoo) {
        bar();
    } else {
        anotherBar();
    }
}

Break elseifs

Yes

e

if (isFoo) {
    bar();
}
else
    if (isFoo1()) {
        bar1();
    }
  else
        if (isFoo2()) {
            bar2();
        }

if (isFoo) {
    bar();
}
else if (isFoo1()) {
    bar1();
}
else if (isFoo2()) }
    bar2;
}

Break one line headers

Yes

xb

void Foo(bool isFoo)
{
    if (isFoo1)
        bar1();

    if (isFoo2) {
        bar2();
    }
}

void Foo(bool isFoo)
{
    if (isFoo1) bar1();

    if (isFoo2) { bar2(); }
}

Add braces

Yes
j
```
if (isFoo) {
    isFoo = false;
}
```
No
```
if (isFoo)
    isFoo = false;
```

Add one line braces

Yes
J
```
if (isFoo)
    { isFoo = false; }
```
No
```
if (isFoo)
    isFoo = false;
```

Remove braces

Yes
xj
```
if (isFoo)
    isFoo = false;
```
No
```
if (isFoo)
{
    isFoo = false;
}
```

Break return type

Yes
xB
```
void
Foo(bool isFoo) {}
```
No
```
void Foo(bool isFoo) {}
```

Break return type decl

Yes
xD
```
void
Foo(bool isFoo);
```
No
```
void Foo(bool isFoo);
```

Attach return type

Yes
xf
```
void Foo(bool isFoo) {}
```
No
```
void
Foo(bool isFoo) {}
```

Attach return type decl

Yes
xh
```
void Foo(bool isFoo);
```
No
```
void
Foo(bool isFoo);
```

Keep one line blocks

Yes

O

if (isFoo)
{ isFoo = false; cout << isFoo << endl; }

//remains unchanged.

if (isFoo)
{ isFoo = false; cout << isFoo << endl; }

Keep one line statements

Yes

o

if (isFoo)
{
    isFoo = false; cout << isFoo << endl;
}

//remains unchanged.

if (isFoo)
{
    isFoo = false; cout << isFoo << endl;
}

Convert tabs

Yes

c

int Foo(bool isBar)********//Foo
{
    int a****= b;
}

int Foo(bool isBar)--->--->//Foo
{
    int a--->= b;
}

Close templates

Yes
xy
```
Stack<int,List<int>> stack1;
```
No
```
Stack< int,List< int > > stack1;
```

Remove comment prefix

Yes

xp

/*
    comment line 1
    comment line 2
*/

/*
 * comment line 1
 * comment line 2
 */

Max code

Yes

xC

if (thisVariable1 == thatVariable1
        || thisVariable2 == thatVariable2
        || thisVariable3 == thatVariable3)
    bar();

if (thisVariable1 == thatVariable1 || thisVariable2 == thatVariable2 || thisVariable3 == thatVariable3)
    bar();

Max code length

Range : 50-200

*Attach to previous short

//Max code length50
if (thisVariable1 == thatVariable1
        || thisVariable2 == thatVariable2
        || thisVariable3 == thatVariable3)
    bar();

//Max code length100
if (thisVariable1 == thatVariable1 || thisVariable2 == thatVariable2
        || thisVariable3 == thatVariable3)
    bar();

Break after logical

Yes

xL

if (thisVariable1 == thatVariable1 ||
        thisVariable2 == thatVariable2 ||
        thisVariable3 == thatVariable3)
    bar();

if (thisVariable1 == thatVariable1
        || thisVariable2 == thatVariable2
        || thisVariable3 == thatVariable3)
    bar();

Objective-C

Pad method prefix

Yes
xQ
```
- (void)foo1;
- (void)foo2;
```
No
```
-(void)foo1;
-    (void)foo2;
```

Unpad method prefix

Yes
xR
```
-(void) foo1;
-(void) foo2;
```
No
```
- (void) foo1;
-     (void) foo2;
```

Pad return type

Yes
xq
```
-(void) foo1;
-(void) foo2;
```
No
```
-(void)foo1;
-(void)   foo2;
```

Unpad return type

Yes
xr
```
-(void)foo1;
-(void)foo2;
```
No
```
-(void) foo1;
-(void)    foo2;
```

Pad param type

Yes

xS

-(void)foo1: (bool) barArg1;
-(void)foo2: (bool) barArg2;

-(void)foo1:(bool)barArg1;
-(void)foo2:    (bool)   barArg2;

Unpad param type

Yes

xs

-(void)foo1:(bool)barArg1;
-(void)foo2:(bool)barArg2;

-(void)foo1: (bool)    barArg1;
-(void)foo2:     (bool)    barArg2;

Align method colon

Yes

xM

-(void)deleteKey:(id)key
         atIndex:(int)index
          ofNode:(Node*)node;

-(void)deleteKey:(id)key
    atIndex:(int)index
    ofNode:(Node*)node;

Pad method colon

Do no change

-(id)write :(NSString*)path
     order :(int)ord
{
     [file writeData :headData
      atOffset :rootOffset];
}

//remains unchanged.

None

xP0

-(id)write:(NSString*)path
     order:(int)ord
{
     [file writeData:headData
      atOffset:rootOffset];
}

All

xP1

-(id)write : (NSString*)path
     order : (int)ord
{
     [file writeData : headData
      atOffset : rootOffset];
}

After

xP2

-(id)write: (NSString*)path
     order: (int)ord
{
     [file writeData: headData
      atOffset: rootOffset];
}

Before

xP3

-(id)write :(NSString*)path
     order :(int)ord
{
     [file writeData :headData
      atOffset :rootOffset];
}