.clang-format

#
# High Performance Simulation (HiPerSim) Lab
# Standard Coding Style
#                                                         
# Author: Anup Shrestha
#         Dr Inanc Senocak
#
# Date: 06-22-2016
#
# Clang v.3.8.0
# Clang 3.8 Documentation (CLANG-FORMAT STYLE OPTIONS)
# http://llvm.org/releases/3.8.0/tools/clang/docs/ClangFormatStyleOptions.html
#

# The style used for all options not specifically
# set in configuration
# Available Options:
#   LLVM     : LLVM coding standards
#   Google   : Google’s C++ style guide
#   Chromium : Chromium’s style guide
#   Mozilla  : Mozilla’s style guide
#   WebKit   : WebKit’s style guide
BasedOnStyle : LLVM

# The extra indent or out-dent of access
# modifiers, e.g. public:
AccessModifierOffset : 0

# If true, horizontally aligns arguments after
# an open bracket. This applies to (round),
# <angle> and [square] brackets
AlignAfterOpenBracket : true

# If true, aligns consecutive assignments
# Example:
#   int aaaa = 12;
#   int b    = 23;
#   int ccc  = 23;
AlignConsecutiveAssignments : true

# If true, aligns consecutive declarations
# Example:
#   int         aaaa = 12;
#   float       b = 23;
#   std::string ccc = 23;
AlignConsecutiveDeclarations: true

# If true, aligns escaped newlines as far left   (--inanc maybe! need to test)
# as possible. Otherwise puts them into the
# right-most column. This does not necessarily 
# mean flushing lings to the left but, rather,
# attempting to align the current line's left
# margin with the previous line's left margin.
# Example:
#   true:
#     if (foo && // Some comment
#     bar) {
#         baz();
#     }
#
#     void foo() {
#         someFunction();
#         someOtherFunction();
#     }
#   false:
#     if (foo && // Some comment
#        bar) {
#             baz();
#     }
#
#     void foo() {
#             someFunction();
#       someOtherFunction();
#     }
#AlignEscapedNewlinesLeft : false

# If true, horizontally align operands of binary
# and ternary expressions
AlignOperands : true

# If true, aligns trailing comments
# Example:
#   true:
#     // Unrelated comment
#     void someFunction() {
#       doWork();     // Does something
#       doMoreWork(); // Does something else
#     }
#   false:
#     // Unrelated comment
#     void someFunction() {
#       doWork(); // Does something
#       doMoreWork(); // Does something else
#     }
AlignTrailingComments : true

# Allow putting all parameters of a function 
# declaration onto the next line even if
# BinPackParameters is false
# Example:
#   true:
#     someFunction(foo,
#                  bar,
#                  baz);
#   false:
#     someFunction(foo,bar,baz);
AllowAllParametersOfDeclarationOnNextLine : false

# Allow contracting simple braced statements to 
# a single line
# E.g., this allows if (a) { return; } 
# to be put on a single line.
AllowShortBlocksOnASingleLine : true

# If true, short case labels will be contracted
# to a single line
# E.g., this allows
#   switch (a) {
#   case 1: x = 1; return;
#   case 2: x = 2; return;
#   default: break
#   }
AllowShortCaseLabelsOnASingleLine : false

# Dependent on the value, int f() { return 0; }
# can be put on a single line
# Available Options:
#   SFS_None   : (in configuration: None) 
#                Never merge functions into a single line.
#   SFS_Empty  : (in configuration: Empty)
#                Only merge empty functions.
#   SFS_Inline : (in configuration: Inline)
#                Only merge functions defined inside a class.
#                Implies “empty”.
#   SFS_All    : (in configuration: All)
#                Merge all functions fitting on a single line.
# (Supported by clang v.3.9)
# AllowShortFunctionsOnASingleLine : Empty

# If true, if (a) return; can be put on
# a single line.
AllowShortIfStatementsOnASingleLine : true

# If true, while (true) continue; can be
# put on a single line.
AllowShortLoopsOnASingleLine : false

# If true, always break before multi-line string literals.
# This flag is meant to make cases where there are multiple
# multi-line strings in a file look more consistent. Thus,
# it will only take effect if wrapping the string at that
# point leads to it being indented ContinuationIndentWidth
# spaces from the start of the line.
AlwaysBreakBeforeMultilineStrings : false

# If true, always break after the template<...> of a
# template declaration.
AlwaysBreakTemplateDeclarations : false

# If false, a function call’s arguments will either
# be all on the same line or will have one line each.
BinPackArguments : true

# If false, a function declaration’s or function
# definition’s parameters will either all be on
# the same line or will have one line each.
BinPackParameters : true

# If true, binary operators will be placed after line breaks.
BreakBeforeBinaryOperators : true

# The brace breaking style to use.  (--inanc we could try other options)
# Available Options:
#   BS_Attach     : (in configuration: Attach)
#                   Always attach braces to surrounding context.
#   BS_Linux      : (in configuration: Linux)
#                   Like Attach, but break before braces on
#                   function, namespace and class definitions.
#   BS_Mozilla    : (in configuration: Mozilla)
#                   Like Attach, but break before braces on
#                   enum, function, and record definitions.
#   BS_Stroustrup : (in configuration: Stroustrup)
#                   Like Attach, but break before function
#                   definitions, catch, and else.
#   BS_Allman     : (in configuration: Allman)
#                   Always break before braces.
#   BS_GNU        : (in configuration: GNU)
#                   Always break before braces and add an extra
#                   level of indentation to braces of control
#                   statements, not to those of class, function
#                   or other definitions.
#   BS_WebKit     : (in configuration: WebKit)
#                   Like Attach, but break before functions.
#   BS_Custom     : (in configuration: Custom)
#                   Configure each individual brace in BraceWrapping.
BreakBeforeBraces : Linux

# If true, ternary operators will be placed after line breaks
BreakBeforeTernaryOperators : true

# Always break constructor initializers before commas
# and align the commas with the colon
BreakConstructorInitializersBeforeComma : false

# The column limit (--inanc 100 because wide screens are the norm these days)
# A column limit of 0 means that there is no column
# limit. In this case, clang-format will respect the
# input’s line breaking decisions within statements
# unless they contradict other rules.
ColumnLimit : 100

# A regular expression that describes comments with (--inanc this may be important for OpenMP/OpenACC)
# special meaning, which should not be split into
# lines or otherwise changed
CommentPragmas : ''


# If the constructor initializers don’t fit on a
# line, put each initializer on its own line
ConstructorInitializerAllOnOneLineOrOnePerLine : false

# The number of characters to use for indentation
# of constructor initializer lists
ConstructorInitializerIndentWidth : 0

# Indent width for line continuations (--inanc we can experiment with 2 spaces)
ContinuationIndentWidth : 0

# If true, format braced lists as best suited
# for C++11 braced lists.
# Important differences:
#   - No spaces inside the braced list.
#   - No line break before the closing brace.
#   - Indentation with the continuation indent,
#     not with the block indent.
# Fundamentally, C++11 braced lists are formatted
# exactly like function calls would be formatted
# in their place. If the braced list follows a
# name (e.g. a type or variable name), clang-format
# formats as if the {} were the parentheses of a
# function call with that name. If there is no name,
# a zero-length name is assumed.
Cpp11BracedListStyle : true

# If true, analyze the formatted file for the most
# common alignment of & and \*.
# PointerAlignment is then used only as fall-back.
DerivePointerAlignment : false

# Disables formatting completely.
DisableFormat : false


# Regular expressions denoting the different
# #include categories used for ordering #includes.
# These regular expressions are matched against
# the filename of an include (including the <> or “”)
# in order. The value belonging to the first matching
# regular expression is assigned and #includes are
# sorted first according to increasing category
# number and then alphabetically within each category.
# If none of the regular expressions match, INT_MAX
# is assigned as category. The main header for a
# source file automatically gets category 0. so that
# it is generally kept at the beginning of the #includes
# (http://llvm.org/docs/CodingStandards.html#include-style).
# However, you can also assign negative priorities if you
# have certain headers that always need to be first.
#
# To configure this in the .clang-format file, use:
# IncludeCategories:
#   - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
#     Priority:        2
#   - Regex:           '^(<|"(gtest|isl|json)/)'
#     Priority:        3
#   - Regex:           '.\*'
#     Priority:        1
# IncludeCategories (std::vector<IncludeCategory>)


# Specify a regular expression of suffixes that are
# allowed in the file-to-main-include mapping.
# When guessing whether a #include is the “main”
# include (to assign category 0, see above), use
# this regex of allowed suffixes to the header stem.
# A partial match is done,so that:
# - “” means “arbitrary suffix” - “$” means “no suffix”
# For example, if configured to “(_test)?$”, then a
# header a.h would be seen as the “main” include in
# both a.cc and a_test.cc.
# IncludeIsMainRegex (std::string)


# Indent case labels one level from the switch statement.
# When false, use the same indentation level as for
# the switch statement. Switch statement body is always
# indented one level more than case labels.
IndentCaseLabels : true

# The number of columns to use for indentation.
IndentWidth : 4

# Indent if a function definition or declaration
# is wrapped after the type.
# (Supported by clang v.3.9)
IndentWrappedFunctionNames : true

# If true, empty lines at the start of blocks are kept.
# (Supported by clang v.3.9)
KeepEmptyLinesAtTheStartOfBlocks : false

# Language, this format style is targeted at.
# Available Options:
#   LK_None       : (in configuration: None)
#                   Do not use.
#   LK_Cpp        : (in configuration: Cpp)
#                   Should be used for C, C++, ObjectiveC, ObjectiveC++.
#   LK_Java       : (in configuration: Java)
#                   Should be used for Java.
#   LK_JavaScript : (in configuration: JavaScript)
#                   Should be used for JavaScript.
#   LK_Proto      : (in configuration: Proto)
#                   Should be used for Protocol Buffers
#                   (https://developers.google.com/protocol-buffers/).
#   LK_TableGen   : (in configuration: TableGen)
#                   Should be used for TableGen code.
# (Supported by clang v.3.9)
Language : Cpp

# A regular expression matching macros that
# start a block.
#MacroBlockBegin (std::string)

# A regular expression matching macros that
# end a block.
# MacroBlockEnd (std::string)

# The maximum number of consecutive empty
# lines to keep.
MaxEmptyLinesToKeep : 1

# The indentation used for namespaces.
# Available Options:
# NI_None  : (in configuration: None)
#            Don’t indent in namespaces.
# NI_Inner : (in configuration: Inner)
#            Indent only in inner namespaces
#            (nested in other namespaces).
# NI_All   : (in configuration: All)
#            Indent in all namespaces.
NamespaceIndentation : None

# The penalty for breaking a function call
# after call(.
# PenaltyBreakBeforeFirstCallParameter (unsigned)

# The penalty for each line break introduced
# inside a comment.
# PenaltyBreakComment (unsigned)

# The penalty for breaking before the first <<.
# PenaltyBreakFirstLessLess (unsigned)

# The penalty for each line break introduced
# inside a string literal.
# PenaltyBreakString (unsigned)

# The penalty for each character outside of
# the column limit.
# PenaltyExcessCharacter (unsigned)

# Penalty for putting the return type of a
# function onto its own line.
# PenaltyReturnTypeOnItsOwnLine (unsigned)


# Pointer and reference alignment style.
# Available Options:
#   PAS_Left   : (in configuration: Left)
#                Align pointer to the left.
#   PAS_Right  : (in configuration: Right)
#                Align pointer to the right.
#   PAS_Middle : (in configuration: Middle)
#                Align pointer in the middle.
# (Supported by clang v.3.9)
PointerAlignment : Right


# If true, clang-format will attempt to re-flow comments. (experiment)
#ReflowComments: true

# If true, clang-format will sort #includes.
SortIncludes : true

# If true, a space may be inserted after C style casts.
SpaceAfterCStyleCast : true

# If false, spaces will be removed before
# assignment operators.
SpaceBeforeAssignmentOperators : true

# Defines in which cases to put a space before
# opening parentheses.
# Available Options:
#   SBPO_Never             : (in configuration: Never)
#                            Never put a space before opening parentheses.
#   SBPO_ControlStatements : (in configuration: ControlStatements)
#                            Put a space before opening parentheses only
#                            after control statement keywords (for/if/while...).
#   SBPO_Always            : (in configuration: Always)
#                            Always put a space before opening parentheses,
#                            except when it’s prohibited by the syntax rules
#                            (in function-like macro definitions) or when
#                            determined by other style rules (after unary
#                            operators, opening parentheses, etc.)
# (Supported by clang v.3.9)
SpaceBeforeParens : ControlStatements

# If true, spaces may be inserted into ().
SpaceInEmptyParentheses : false

# The number of spaces before trailing
# line comments (// - comments).
# This does not affect trailing block comments
# (/* - comments) as those commonly have
# different usage patterns and a number of special cases.
SpacesBeforeTrailingComments : 1

# If true, spaces will be inserted after
# < and before > in template argument lists.
SpacesInAngles : false

# If true, spaces may be inserted into C style casts.
SpacesInCStyleCastParentheses : false

# If true, spaces will be inserted after ( and before ).
SpacesInParentheses : false

# If true, spaces will be inserted after [ and before ].
# (Supported by clang v.3.9)
SpacesInSquareBrackets : false

# Format compatible with this standard,
# e.g. use A<A<int> > instead of A<A<int>> for LS_Cpp03.
# Available Options:
#   LS_Cpp03 : (in configuration: Cpp03)
#              Use C++03-compatible syntax.
#   LS_Cpp11 : (in configuration: Cpp11)
#              Use features of C++11
#              (e.g. A<A<int>> instead of A<A<int> >).
#   LS_Auto  : (in configuration: Auto)
#              Automatic detection based on the input.
Standard : Auto

# The number of columns used for tab stops.
TabWidth : 4


# The way to use tab characters in the resulting file.
# Available Options:
#   UT_Never          : (in configuration: Never)
#                       Never use tab.
#   UT_ForIndentation : (in configuration: ForIndentation)
#                       Use tabs only for indentation.
#   UT_Always         : (in configuration: Always)
#                       Use tabs whenever we need to fill
#                       whitespace that spans at least from
#                       one tab stop to the next one.
UseTab : ForIndentation