Difference between revisions of "Astyle reformat"

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

becomes:

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

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

becomes:

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

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

becomes:

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

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

becomes (with indented 'error:'):

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

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

becomes:

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

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

becomes:

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

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

becomes:

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

fooArray[] = { red,
         green,
         blue };
fooFunction(barArg1,
         barArg2,
         barArg3);

becomes (with larger value):

fooArray[] = { red,
               green,
               blue };
fooFunction(barArg1,
            barArg2,
            barArg3);

The valid values are:

• 0: no minimal indent. The lines will be aligned with the parenthesis on the preceding line.
• 1: indent at least one additional indent.
• 2: indent at least two additional indents.
• 3: indent at least one-half an additional indent. This is intended for large indents (e.g. 8).

The default value is 2, two additional indents.

// default setting makes this non-bracketed code clear
if (a < b
        || c > d)
    foo++;

// but creates an exaggerated indent in this bracketed code
if (a < b
        || c > d)
{
    foo++;
}

becomes (when setting min. conditional indent = 0):

// setting makes this non-bracketed code less clear
if (a < b
    || c > d)
    foo++;

// but makes this bracketed code clearer
if (a < b
    || c > d)
{
    foo++;
}

• allman
• ansi
• bsd
• break

Allman style formatting/indenting uses broken brackets.

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

• java
• attach

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

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

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

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

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

Extra indentation is added to blocks within a function. The opening bracket for namespaces, classes, and functions is not indented.

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

Also known as Kernel Normal Form (KNF) style, this is the style used in the Linux kernel.

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

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

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

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

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

if (isFoo)
    isFoo = false;

becomes:

if (isFoo) {
    isFoo = false;
}

if (isFoo)
    isFoo = false;

becomes:

if (isFoo)
    { isFoo = false; }

char* foo1;
char & foo2;
String ^s1;

becomes (with align pointer = type):

char* foo1;
char& foo2;
String^ s1;

char* foo1;
char & foo2;
String ^s1;

becomes (with align pointer = middle):

char * foo1;
char & foo2;
String ^ s1;

char* foo1;
char & foo2;
String ^s1;

becomes (with align pointer = name):

char *foo1;
char &foo2;
String ^s1;

char &foo1;

becomes (with align reference = type):

char& foo1;

char& foo2;

becomes (with align reference = middle):

char & foo2;

char& foo3;

becomes (with align reference = name):

char &foo3;

Some code will not be broken, such as comments, quotes, and arrays. If used with keep one line blocks or add one line brackets the blocks will NOT be broken. If used with keep one line statements the statements will be broken at a semicolon if the line goes over the maximum length. If there is no available break point within the max code length, the line will be broken at the first available break point after the max code length.

By default logical conditionals will be placed first on the new line. The option break after logical will cause the logical conditionals to be placed last on the previous line. This option has no effect without max. code length.

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

becomes:

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

becomes (with break after logical):

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

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

becomes:

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

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

becomes:

isFoo = true;

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

isBar = false;

The all option pads empty lines around header blocks (e.g. 'if', 'for', 'while', ...). Treat closing header blocks (e.g. 'else', 'catch') as stand-alone blocks.

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

becomes:

isFoo = true;

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

isBar = false;

Stack< int,List< int > > stack1;

becomes:

Stack<int,List<int>> stack1;

void Foo()
{

    foo1 = 1;

    foo2 = 2;

}

becomes:

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

The fill option fills empty lines with the white space of the previous line.

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

remains unchanged.

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

remains unchanged.

if (isFoo) DoBar();

remains also unchanged.

Some code will not be broken, such as comments, quotes, and arrays. If used with keep one line blocks or add one line brackets the blocks will NOT be broken. If used with keep one line statements the statements will be broken at a semicolon if the line goes over the maximum length. If there is no available break point within the max code length, the line will be broken at the first available break point after the max code length.

first-paren-out
inserts space padding around the first parenthesis in a series on the outside only. Any end of line comments will remain in the original column, if possible. This can be used with unpad-paren below to remove unwanted spaces. If used with pad-paren or pad-paren-out, this option will be ignored. If used with pad-paren-in, the result will be the same as pad-paren.

if (isFoo((a+2), b))
    bar(a, b);

becomes:

if (isFoo ((a+2), b))
    bar (a, b);

oper
inserts space padding around operators. Any end of line comments will remain in the original column, if possible. Note that there is no option to unpad. Once padded, they stay padded.

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

becomes:

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

paren
inserts space padding around parenthesis on both the outside and the inside. Any end of line comments will remain in the original column, if possible.

if (isFoo((a+2), b))
    bar(a, b);

becomes:

if ( isFoo ( ( a+2 ), b ) )
    bar ( a, b );

paren-in
inserts space padding around parenthesis on the inside only. Any end of line comments will remain in the original column, if possible. This can be used with unpad-paren below to remove unwanted spaces.

if (isFoo((a+2), b))
    bar(a, b);

becomes:

if ( isFoo( ( a+2 ), b ) )
    bar( a, b );

paren-out
inserts space padding around parenthesis on the outside only. Any end of line comments will remain in the original column, if possible. This can be used with unpad-paren below to remove unwanted spaces.

if (isFoo((a+2), b))
    bar(a, b);

becomes:

if (isFoo ( (a+2), b) )
    bar (a, b);

header
inserts space padding after parenthesis headers only (e.g. 'if', 'for', 'while', ...). Any end of line comments will remain in the original column, if possible. This can be used with unpad-paren to remove unwanted spaces.

if(isFoo((a+2), b))
    bar(a, b);

becomes:

if (isFoo((a+2), b))
    bar(a, b);

unpad-paren
removes extra space padding around parenthesis on the inside and outside. Any end of line comments will remain in the original column, if possible. This option can be used in combination with the parenthesis padding options paren, paren-out, paren-in, and header above. Only padding that has not been requested by other options will be removed.

For example, if a source has parenthesis padded on both the inside and outside, and you want inside only. You need to use unpad-paren to remove the outside padding, and paren-in to retain the inside padding. Using only paren-in would not remove the outside padding.

if ( isFoo( ( a+2 ), b ) )
    bar ( a, b );

becomes (with no padding option requested):

if(isFoo((a+2), b))
    bar(a, b);