.clang-format

Language: C
Language: Cpp

# Aligns parameters contained within open brackets
# .e.g longFunction (argument1,
#                    argument2)
AlignAfterOpenBracket: Align

# Aligns the assignment operators
AlignConsecutiveAssignments: AcrossComments

# Aligns the variable names
AlignConsecutiveDeclarations: AcrossComments

# Aligns consecutive bitfields
AlignConsecutiveBitFields: AcrossComments

# Aligns macros
#define SHORT_NAME       42
#define LONGER_NAME      0x007f
#define EVEN_LONGER_NAME (2)
#define foo(x)           (x * x)
#define bar(y, z)        (y + z)
AlignConsecutiveMacros: AcrossComments

# Align "\" new-line characters as far left as possible
# define A    \
#   int aaaa; \
#   int b;    \
#   int dddddddddd;
AlignEscapedNewlinesLeft: 'true'

# Aligns operands that need to be split over multiple lines
AlignOperands: 'true'

# Align comments
AlignTrailingComments: 'true'

# if function declaration doesn't fit on a line, put all params
# of function dec. onto next line. Overrides BinPackParameters option
# void myFunc(
#       int a, int b, int c, int d, int e);
AllowAllParametersOfDeclarationOnNextLine: 'false'

# Allows braced statements to be on a single line
# e.g. if (eval) { return true; }
AllowShortBlocksOnASingleLine: 'true'

# only merge functions defined inside a class, including empty ones
# Other options include "empty" where onyl empty functions are inline
# "InlineOnly" which excludes empty functions and "All" which merges
# all functions fitting on a single line
AllowShortFunctionsOnASingleLine: Inline

# single line conditionals can be put on a single line
# if (a) operation;
# vs.
# if (a)
#     operation;
AllowShortIfStatementsOnASingleLine: 'false'

# self-explanatory.
AllowShortCaseLabelsOnASingleLine: 'false'

# self-explanatory. for(;;) operation;
AllowShortLoopsOnASingleLine: 'true'

# break long strings into multiple lines and then align the strings
AlwaysBreakBeforeMultilineStrings: 'false'

# Forces the params and names following the template decl. to
# break into multiline
# e.g.
# template <typename T>
# T foo (int a, int b)
AlwaysBreakTemplateDeclarations: 'false'

# if false, a function call's arguments get their own lines
BinPackArguments: 'true'

# if false, a function declaration's args get their own lines
BinPackParameters: 'true'

# self explanatory
BitFieldColonSpacing: After

# forces the operator to be the end of line and the second monomial
# term to a new line
# e.g. val = a +
#            b /
#            c;
BreakBeforeBinaryOperators: None

# forces each operand to a new line
BreakBeforeTernaryOperators: 'true'

BreakBeforeBraces: Custom
BraceWrapping:
{
  AfterCaseLabel: 'true'
  AfterClass: 'true'
  AfterControlStatement: 'true'
  AfterEnum: 'true'
  AfterFunction: 'true'
  AfterNamespace: 'true'
  AfterObjCDeclaration: 'true'
  AfterStruct: 'true'
  AfterUnion: 'true'
  AfterExternBlock: 'false'
  BeforeCatch: 'true'
  BeforeElse: 'true'
  IndentBraces: 'false'
  SplitEmptyFunction: 'false'
  SplitEmptyRecord: 'false'
  SplitEmptyNamespace: 'false'
}

# true:
# const char* x = "veryVeryVeryVeryVeryVe"
#                 "ryVeryVeryVeryVeryVery"
#                 "VeryLongString";
BreakStringLiterals: 'true'

#ExperimentalAutoDetectBinPacking: true

# we don't believe in ColumnLimits here...everyone has infinitely wide screens
ColumnLimit: '0'

# stop clang from trying to format the special
# Cube-generated starting and ending comments
CommentPragmas: '^( #####(\#+))'

# Either fits all the constructor call args onto one line
# or each param gets their own line if they don't fit
ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'

# number of char to use for indentation of contructor initializer lists
# class::construct() : \noOfChars a(a), \noOfChars b(b) {};
ConstructorInitializerIndentWidth: '2'

# indent width length for line continuations
# int i =
# \noOfChars function(
# 2*\noOfChars arg);
ContinuationIndentWidth: '4'

# Format braced lists as best suited for C++11 braced lists
# Important Differences (if 'true')
# - no spaces inside the braced lists
# - no line break before closing brace
# - indentation with the continuation indentation, not with block indent
Cpp11BracedListStyle: 'false'

# how to sort include blocks
IncludeBlocks: Preserve

# "case" keywords are indented from the "switch"
IndentCaseLabels: 'true'

# self-explanatory
IndentWidth: '4'

# indent if function def or declaration is wrapped after the type
# e.g.
# stupidlyLongReturnType
#   stupidlyLongFunctionDeclaration();
IndentWrappedFunctionNames: 'true'

# preprocessor block indenting
IndentPPDirectives: AfterHash

# self-explanatory, apparently can't be used with bin packing
# InsertTrailingCommas: Wrapped

# empty line at start of new scope is kept
KeepEmptyLinesAtTheStartOfBlocks: 'false'

# how many empty lines to leave
MaxEmptyLinesToKeep: '2'

# Changed this. Made it C specific. Should also be right aligned.
# "Left"   : Leave the pointer character in a variable declaration to the left (e.g. int* a)
# "Right"  : Align pointer to right (e.g. int *a)
# "Middle" : Align pointer between type and var name (e.g. int * a)
PointerAlignment: Left

# how much to indent subsequent preprocessor blocks by
PPIndentWidth: '1'

# if "None", no namespaces are indented
# if "Inner", only inner namespaces are indented
# if "All", every new scope is indented (intuitive)
NamespaceIndentation: Inner

# splits long comments into multiline
ReflowComments: 'true'

# lists of the include headers in alphabetical order
SortIncludes: 'true'

# TODO: Enable me when clang-format has been updated to understand me
#SortUsingDeclarations: 'false'

# inserts a space between casts and the variables they're targeting
SpaceAfterCStyleCast: 'false'

# TODO: Enable me when clang-format has been updated to understand me
#SpaceAfterTemplateKeyword: 'false'

# self-explanatory
SpaceBeforeAssignmentOperators: 'true'

# "Never"             : don't put a space before opening parantheses
# "ControlStatements" : only put space before parantheses belonging to ctrl statements
# "Always"            : always put a space before opening params
SpaceBeforeParens: ControlStatements

# self-explanatory
SpaceInEmptyParentheses: 'false'

# number of spaces before c-style comments "//"
SpacesBeforeTrailingComments: '4'

# spaces inserted after < and before > in template argument lists
SpacesInAngles: 'false'

# Spaces in parantheses for casting e.g. ( int )
SpacesInCStyleCastParentheses: 'false'

# Spaces inserted between array brackets
SpacesInContainerLiterals: 'false'

# self-explanatory
SpacesInParentheses: 'false'

# self-explanatory
SpacesInSquareBrackets: 'false'

# self-explanatory
TabWidth: '4'

# self-explanatory
UseTab: Never

# macros which have sensitive whitespace and should be left alone
WhitespaceSensitiveMacros: ['set_value', 'set_scale', 'set_raw']