.astylerc

# ~/.astylerc
#
# Courtesy of HN's super_mario: http://news.ycombinator.com/item?id=5348401
# 

# Use K&R formatting style
style=kr
    
# Indent class and struct blocks so that the blocks 'public', 'private' and
# 'protected' are indented. This option is effective in C++ files only
indent-classes
    
# Indent 'switch' blocks so that the 'case X:' statements are indented with 
# the switch block. The entire case block is indented.
# 
# For example: 
# 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;
#     }
# }
#indent-switches
    
# Indent C++ namespaces (this option has no effect on other file types)
# Add extra indentation to namespace blocks.
# For example:
# namespace foospace
# {
# class Foo
# {
#     public:
#         Foo();
#         virtual ~Foo();
# };
# }
#
# becomes
# 
# namespace foospace
# {
#     class Foo
#     {
#         public:
#             Foo();
#             virtual ~Foo();
#     };
# }
indent-namespaces
    
# Indent multi line preprocessor definitions ending with a backslash
# For example:
#
# #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)))
# 
indent-preprocessor
    
# Indent C++ comments beginning in column one. 
# For example
# 
# void Foo()\n"
# {
# // comment
#     if (isFoo)
#         bar();
# }
# 
# becomes:
# 
# void Foo()\n"
# {
#     // comment
#     if (isFoo)
#         bar();
# }
# 
indent-col1-comments
    
# Pad empty lines around header blocks (e.g. 'if', 'for', 'while'...).
# 
# isFoo = true;
# if (isFoo) {
#     bar();
# } else {
#     anotherBar();
# }
# isBar = false;
# 
# becomes:
# 
# isFoo = true;
# 
# if (isFoo) {
#     bar();
# } else {
#     anotherBar();
# }
# 
# isBar = false;
# 
break-blocks
    
# Insert 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--);
# 
pad-oper
    
    
# Insert space padding after paren 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, b))
#     bar(a, b);
# 
# becomes:
# 
# if (isFoo(a, b))
#     bar(a, b);
# 
pad-header
    
# Remove 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 paren padding options pad‑paren,
# pad‑paren‑out, pad‑paren‑in, and pad‑header above. Only padding that has not
# been requested by other options will be removed.
# 
# For example, if a source has parens padded on both the inside and outside,
# and you want inside only. You need to use unpad-paren to remove the outside
# padding, and pad‑paren‑in to retain the inside padding. Using only
# pad‑paren‑in would not remove the outside padding.
# 
# if ( isFoo( a, b ) )
#     bar ( a, b );
# 
# becomes (with no padding option requested):
# 
# if(isFoo(a, b))
#     bar(a, b);
# 
unpad-paren
    
# Delete empty lines within a function or method. Empty lines outside of
# functions or methods are NOT deleted. If used with break-blocks or
# break-blocks=all it will delete all lines EXCEPT the lines added by the
# break-blocks options.
# 
# void Foo()
# {
# 	
#     foo1 = 1;
# 	
#     foo2 = 2;
# 	
# }
# 
# becomes:
# 
# void Foo()
# {
#     foo1 = 1;
#     foo2 = 2;
# }
# 
delete-empty-lines
    
# Attach a pointer or reference operator (* or &) to either the variable type
# (left) or variable name (right), or place it between the type and name
# (middle). The spacing between the type and name will be preserved, if
# possible. To format references separately use the following align-reference
# option.
# 
# char *foo1;
# char &foo2;
# 
# becomes (with align-pointer=type):
# 
# char* foo1;
# char& foo2;
# 
# char* foo1;
# char& foo2;
# 
# becomes (with align-pointer=middle):
# 
# char * foo1;
# char & foo2;
# 
# char* foo1;
# char& foo2;
# 
# becomes (with align-pointer=name):
# 
# char *foo1;
# char &foo2;
# 
align-pointer=name
    
# Set the minimal indent that is added when a header is built of multiple
# lines. This indent helps to easily separate the header from the command
# statements that follow. The value for # indicates a number of indents and is
# a minimum value. The indent may be greater to align with the data on the
# previous line.
# The valid values are:
# 0 - no minimal indent. The lines will be aligned with the paren 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++;
# }
# 
min-conditional-indent=0
    
# Set the  maximum of # spaces to indent a continuation line. The  # indicates
# a number of columns and must not be greater than 120. If no # is set, the
# default value of 40 will be used. A maximum of less than two indent lengths
# will be ignored. This option will prevent continuation lines from extending
# too far to the right. Setting a larger value will allow the code to be
# extended further to the right.
# 
# fooArray[] = { red,
#          green,
#          blue };
# 
# fooFunction(barArg1,
#          barArg2,
#          barArg3);
# 
# becomes (with larger value):
# 
# fooArray[] = { red,
#                green,
#                blue };
# 
# fooFunction(barArg1,
#             barArg2,
#             barArg3);
# 
max-instatement-indent=9