Clang-Format Style Options¶

Clang-Format Style Options describes configurable formatting style optionssupported byLibFormat andClangFormat.

When usingclang-format command line utility orclang::format::reformat(...) functions from code, one can either use one ofthe predefined styles (LLVM, Google, Chromium, Mozilla, WebKit, Microsoft) orcreate a custom style by configuring specific style options.

Configuring Style with clang-format¶

clang-format supports two ways to provide custom style options:directly specify style configuration in the-style= command line option oruse-style=file and put style configuration in the.clang-format or_clang-format file in the project directory.

When using-style=file,clang-format for each input file willtry to find the.clang-format file located in the closest parent directoryof the input file. When the standard input is used, the search is started fromthe current directory.

When using-style=file:<format_file_path>,clang-format foreach input file will use the format file located at<format_file_path>.The path may be absolute or relative to the working directory.

The.clang-format file uses YAML format:

key1:value1key2:value2# A comment....

The configuration file can consist of several sections each having differentLanguage: parameter denoting the programming language this section of theconfiguration is targeted at. See the description of theLanguage optionbelow for the list of supported languages. The first section may have nolanguage set, it will set the default style options for all languages.Configuration sections for specific language will override options set in thedefault section.

Whenclang-format formats a file, it auto-detects the language usingthe file name. When formatting standard input or a file that doesn’t have theextension corresponding to its language,-assume-filename= option can beused to override the file nameclang-format uses to detect thelanguage.

An example of a configuration file for multiple languages:

---# We'll use defaults from the LLVM style, but with 4 columns indentation.BasedOnStyle:LLVMIndentWidth:4---Language:Cpp# Force pointers to the type for C++.DerivePointerAlignment:falsePointerAlignment:Left---Language:JavaScript# Use 100 columns for JS.ColumnLimit:100---Language:Proto# Don't format .proto files.DisableFormat:true---Language:CSharp# Use 100 columns for C#.ColumnLimit:100...

An easy way to get a valid.clang-format file containing all configurationoptions of a certain predefined style is:

clang-format -style=llvm -dump-config > .clang-format

When specifying configuration in the-style= option, the same configurationis applied for all input files. The format of the configuration is:

-style='{key1: value1, key2: value2, ...}'

Disabling Formatting on a Piece of Code¶

Clang-format understands also special comments that switch formatting in adelimited range. The code between a comment//clang-formatoff or/*clang-formatoff*/ up to a comment//clang-formaton or/*clang-formaton*/ will not be formatted. The comments themselves will beformatted (aligned) normally. Also, a colon (:) and additional text mayfollow//clang-formatoff or//clang-formaton to explain whyclang-format is turned off or back on.

intformatted_code;// clang-format offvoidunformatted_code;// clang-format onvoidformatted_code_again;

Configuring Style in Code¶

When usingclang::format::reformat(...) functions, the format is specifiedby supplying theclang::format::FormatStylestructure.

Configurable Format Style Options¶

This section lists the supported style options. Value type is specified foreach option. For enumeration types possible values are specified both as a C++enumeration member (with a prefix, e.g.LS_Auto), and as a value usable inthe configuration (without a prefix:Auto).

BasedOnStyle (String)¶

The style used for all options not specifically set in the configuration.

This option is supported only in theclang-format configuration(both within-style='{...}' and the.clang-format file).

Possible values:

LLVMA style complying with theLLVM coding standards
GoogleA style complying withGoogle’s C++ style guide
ChromiumA style complying withChromium’s style guide
MozillaA style complying withMozilla’s style guide
WebKitA style complying withWebKit’s style guide
MicrosoftA style complying withMicrosoft’s style guide
GNUA style complying with theGNU coding standards
InheritParentConfigNot a real style, but allows to use the.clang-format file from theparent directory (or its parent if there is none). If there is no parentfile found it falls back to thefallback style, and applies the changesto that.
With this option you can overwrite some parts of your main style for yoursubdirectories. This is also possible through the command line, e.g.:--style={BasedOnStyle:InheritParentConfig,ColumnLimit:20}

AccessModifierOffset (Integer)clang-format 3.3¶: The extra indent or outdent of access modifiers, e.g.public:.

AlignAfterOpenBracket (BracketAlignmentStyle)clang-format 3.8¶

Iftrue, horizontally aligns arguments after an open bracket.

This applies to round brackets (parentheses), angle brackets and squarebrackets.

Possible values:

BAS_Align (in configuration:Align)Align parameters on the open bracket, e.g.:
```
someLongFunction(argument1,argument2);
```
BAS_DontAlign (in configuration:DontAlign)Don’t align, instead useContinuationIndentWidth, e.g.:
```
someLongFunction(argument1,argument2);
```
BAS_AlwaysBreak (in configuration:AlwaysBreak)Always break after an open bracket, if the parameters don’t fiton a single line, e.g.:
```
someLongFunction(argument1,argument2);
```
BAS_BlockIndent (in configuration:BlockIndent)Always break after an open bracket, if the parameters don’t fiton a single line. Closing brackets will be placed on a new line.E.g.:
```
someLongFunction(argument1,argument2)
```
Note
This currently only applies to braced initializer lists (whenCpp11BracedListStyle istrue) and parentheses.

AlignArrayOfStructures (ArrayInitializerAlignmentStyle)clang-format 13¶

If notNone, when using initialization for an array of structsaligns the fields into columns.

Note

As of clang-format 15 this option only applied to arrays with equalnumber of columns per row.

Possible values:

AIAS_Left (in configuration:Left)Align array column and left justify the columns e.g.:
```
structtestdemo[]={{56,23,"hello"},{-1,93463,"world"},{7,5,"!!"}};
```
AIAS_Right (in configuration:Right)Align array column and right justify the columns e.g.:
```
structtestdemo[]={{56,23,"hello"},{-1,93463,"world"},{7,5,"!!"}};
```
AIAS_None (in configuration:None)Don’t align array initializer columns.

AlignConsecutiveAssignments (AlignConsecutiveStyle)clang-format 3.8¶

Style of aligning consecutive assignments.

Consecutive will result in formattings like:

inta=1;intsomelongname=2;doublec=3;

Nested configuration flags:

Alignment options.

They can also be read as a whole for compatibility. The choices are:

None
Consecutive
AcrossEmptyLines
AcrossComments
AcrossEmptyLinesAndComments

For example, to align across empty lines and not across comments, eitherof these work.

AlignConsecutiveAssignments:AcrossEmptyLinesAlignConsecutiveAssignments:Enabled:trueAcrossEmptyLines:trueAcrossComments:false

boolEnabled Whether aligning is enabled.

#define SHORT_NAME       42#define LONGER_NAME      0x007f#define EVEN_LONGER_NAME (2)#define foo(x)           (x * x)#define bar(y, z)        (y + z)inta=1;intsomelongname=2;doublec=3;intaaaa:1;intb:12;intccc:8;intaaaa=12;floatb=23;std::stringccc;

boolAcrossEmptyLines Whether to align across empty lines.

true:inta=1;intsomelongname=2;doublec=3;intd=3;false:inta=1;intsomelongname=2;doublec=3;intd=3;

boolAcrossComments Whether to align across comments.

true:intd=3;/* A comment. */doublee=4;false:intd=3;/* A comment. */doublee=4;

boolAlignCompound Only forAlignConsecutiveAssignments. Whether compound assignmentslike+= are aligned along with=.
```
true:a&=2;bbb=2;false:a&=2;bbb=2;
```
boolAlignFunctionDeclarations Only forAlignConsecutiveDeclarations. Whether function declarationsare aligned.
```
true:unsignedintf1(void);voidf2(void);size_tf3(void);false:unsignedintf1(void);voidf2(void);size_tf3(void);
```
boolAlignFunctionPointers Only forAlignConsecutiveDeclarations. Whether function pointers arealigned.
```
true:unsignedi;int&r;int*p;int(*f)();false:unsignedi;int&r;int*p;int(*f)();
```
boolPadOperators Only forAlignConsecutiveAssignments. Whether short assignmentoperators are left-padded to the same length as long ones in order toput all assignment operators to the right of the left hand side.
```
true:a>>=2;bbb=2;a=2;bbb>>=2;false:a>>=2;bbb=2;a=2;bbb>>=2;
```

AlignConsecutiveBitFields (AlignConsecutiveStyle)clang-format 11¶

Style of aligning consecutive bit fields.

Consecutive will align the bitfield separators of consecutive lines.This will result in formattings like:

intaaaa:1;intb:12;intccc:8;

Nested configuration flags:

Alignment options.

They can also be read as a whole for compatibility. The choices are:

None
Consecutive
AcrossEmptyLines
AcrossComments
AcrossEmptyLinesAndComments

For example, to align across empty lines and not across comments, eitherof these work.

AlignConsecutiveBitFields:AcrossEmptyLinesAlignConsecutiveBitFields:Enabled:trueAcrossEmptyLines:trueAcrossComments:false

boolEnabled Whether aligning is enabled.

#define SHORT_NAME       42#define LONGER_NAME      0x007f#define EVEN_LONGER_NAME (2)#define foo(x)           (x * x)#define bar(y, z)        (y + z)inta=1;intsomelongname=2;doublec=3;intaaaa:1;intb:12;intccc:8;intaaaa=12;floatb=23;std::stringccc;

boolAcrossEmptyLines Whether to align across empty lines.

true:inta=1;intsomelongname=2;doublec=3;intd=3;false:inta=1;intsomelongname=2;doublec=3;intd=3;

boolAcrossComments Whether to align across comments.

true:intd=3;/* A comment. */doublee=4;false:intd=3;/* A comment. */doublee=4;

boolAlignCompound Only forAlignConsecutiveAssignments. Whether compound assignmentslike+= are aligned along with=.
```
true:a&=2;bbb=2;false:a&=2;bbb=2;
```
boolAlignFunctionDeclarations Only forAlignConsecutiveDeclarations. Whether function declarationsare aligned.
```
true:unsignedintf1(void);voidf2(void);size_tf3(void);false:unsignedintf1(void);voidf2(void);size_tf3(void);
```
boolAlignFunctionPointers Only forAlignConsecutiveDeclarations. Whether function pointers arealigned.
```
true:unsignedi;int&r;int*p;int(*f)();false:unsignedi;int&r;int*p;int(*f)();
```
boolPadOperators Only forAlignConsecutiveAssignments. Whether short assignmentoperators are left-padded to the same length as long ones in order toput all assignment operators to the right of the left hand side.
```
true:a>>=2;bbb=2;a=2;bbb>>=2;false:a>>=2;bbb=2;a=2;bbb>>=2;
```

AlignConsecutiveDeclarations (AlignConsecutiveStyle)clang-format 3.8¶

Style of aligning consecutive declarations.

Consecutive will align the declaration names of consecutive lines.This will result in formattings like:

intaaaa=12;floatb=23;std::stringccc;

Nested configuration flags:

Alignment options.

They can also be read as a whole for compatibility. The choices are:

None
Consecutive
AcrossEmptyLines
AcrossComments
AcrossEmptyLinesAndComments

For example, to align across empty lines and not across comments, eitherof these work.

AlignConsecutiveDeclarations:AcrossEmptyLinesAlignConsecutiveDeclarations:Enabled:trueAcrossEmptyLines:trueAcrossComments:false

boolEnabled Whether aligning is enabled.

#define SHORT_NAME       42#define LONGER_NAME      0x007f#define EVEN_LONGER_NAME (2)#define foo(x)           (x * x)#define bar(y, z)        (y + z)inta=1;intsomelongname=2;doublec=3;intaaaa:1;intb:12;intccc:8;intaaaa=12;floatb=23;std::stringccc;

boolAcrossEmptyLines Whether to align across empty lines.

true:inta=1;intsomelongname=2;doublec=3;intd=3;false:inta=1;intsomelongname=2;doublec=3;intd=3;

boolAcrossComments Whether to align across comments.

true:intd=3;/* A comment. */doublee=4;false:intd=3;/* A comment. */doublee=4;

boolAlignCompound Only forAlignConsecutiveAssignments. Whether compound assignmentslike+= are aligned along with=.
```
true:a&=2;bbb=2;false:a&=2;bbb=2;
```
boolAlignFunctionDeclarations Only forAlignConsecutiveDeclarations. Whether function declarationsare aligned.
```
true:unsignedintf1(void);voidf2(void);size_tf3(void);false:unsignedintf1(void);voidf2(void);size_tf3(void);
```
boolAlignFunctionPointers Only forAlignConsecutiveDeclarations. Whether function pointers arealigned.
```
true:unsignedi;int&r;int*p;int(*f)();false:unsignedi;int&r;int*p;int(*f)();
```
boolPadOperators Only forAlignConsecutiveAssignments. Whether short assignmentoperators are left-padded to the same length as long ones in order toput all assignment operators to the right of the left hand side.
```
true:a>>=2;bbb=2;a=2;bbb>>=2;false:a>>=2;bbb=2;a=2;bbb>>=2;
```

AlignConsecutiveMacros (AlignConsecutiveStyle)clang-format 9¶

Style of aligning consecutive macro definitions.

Consecutive will result in formattings like:

#define SHORT_NAME       42#define LONGER_NAME      0x007f#define EVEN_LONGER_NAME (2)#define foo(x)           (x * x)#define bar(y, z)        (y + z)

Nested configuration flags:

Alignment options.

They can also be read as a whole for compatibility. The choices are:

None
Consecutive
AcrossEmptyLines
AcrossComments
AcrossEmptyLinesAndComments

For example, to align across empty lines and not across comments, eitherof these work.

AlignConsecutiveMacros:AcrossEmptyLinesAlignConsecutiveMacros:Enabled:trueAcrossEmptyLines:trueAcrossComments:false

boolEnabled Whether aligning is enabled.

#define SHORT_NAME       42#define LONGER_NAME      0x007f#define EVEN_LONGER_NAME (2)#define foo(x)           (x * x)#define bar(y, z)        (y + z)inta=1;intsomelongname=2;doublec=3;intaaaa:1;intb:12;intccc:8;intaaaa=12;floatb=23;std::stringccc;

boolAcrossEmptyLines Whether to align across empty lines.

true:inta=1;intsomelongname=2;doublec=3;intd=3;false:inta=1;intsomelongname=2;doublec=3;intd=3;

boolAcrossComments Whether to align across comments.

true:intd=3;/* A comment. */doublee=4;false:intd=3;/* A comment. */doublee=4;

boolAlignCompound Only forAlignConsecutiveAssignments. Whether compound assignmentslike+= are aligned along with=.
```
true:a&=2;bbb=2;false:a&=2;bbb=2;
```
boolAlignFunctionDeclarations Only forAlignConsecutiveDeclarations. Whether function declarationsare aligned.
```
true:unsignedintf1(void);voidf2(void);size_tf3(void);false:unsignedintf1(void);voidf2(void);size_tf3(void);
```
boolAlignFunctionPointers Only forAlignConsecutiveDeclarations. Whether function pointers arealigned.
```
true:unsignedi;int&r;int*p;int(*f)();false:unsignedi;int&r;int*p;int(*f)();
```
boolPadOperators Only forAlignConsecutiveAssignments. Whether short assignmentoperators are left-padded to the same length as long ones in order toput all assignment operators to the right of the left hand side.
```
true:a>>=2;bbb=2;a=2;bbb>>=2;false:a>>=2;bbb=2;a=2;bbb>>=2;
```

AlignConsecutiveShortCaseStatements (ShortCaseStatementsAlignmentStyle)clang-format 17¶

Style of aligning consecutive short case labels.Only applies ifAllowShortCaseExpressionOnASingleLine orAllowShortCaseLabelsOnASingleLine istrue.

# Example of usage:AlignConsecutiveShortCaseStatements:Enabled:trueAcrossEmptyLines:trueAcrossComments:trueAlignCaseColons:false

Nested configuration flags:

Alignment options.

boolEnabled Whether aligning is enabled.

true:switch(level){caselog::info:return"info:";caselog::warning:return"warning:";default:return"";}false:switch(level){caselog::info:return"info:";caselog::warning:return"warning:";default:return"";}

boolAcrossEmptyLines Whether to align across empty lines.

true:switch(level){caselog::info:return"info:";caselog::warning:return"warning:";default:return"";}false:switch(level){caselog::info:return"info:";caselog::warning:return"warning:";default:return"";}

boolAcrossComments Whether to align across comments.

true:switch(level){caselog::info:return"info:";caselog::warning:return"warning:";/* A comment. */default:return"";}false:switch(level){caselog::info:return"info:";caselog::warning:return"warning:";/* A comment. */default:return"";}

boolAlignCaseArrows Whether to align the case arrows when aligning short case expressions.

true:i=switch(day){caseTHURSDAY,SATURDAY->8;caseWEDNESDAY->9;default->0;};false:i=switch(day){caseTHURSDAY,SATURDAY->8;caseWEDNESDAY->9;default->0;};

boolAlignCaseColons Whether aligned case labels are aligned on the colon, or on the tokensafter the colon.

true:switch(level){caselog::info:return"info:";caselog::warning:return"warning:";default:return"";}false:switch(level){caselog::info:return"info:";caselog::warning:return"warning:";default:return"";}

AlignConsecutiveTableGenBreakingDAGArgColons (AlignConsecutiveStyle)clang-format 19¶

Style of aligning consecutive TableGen DAGArg operator colons.If enabled, align the colon inside DAGArg which have line break inside.This works only when TableGenBreakInsideDAGArg is BreakElements orBreakAll and the DAGArg is not excepted byTableGenBreakingDAGArgOperators’s effect.

letdagarg=(insa:$src1,aa:$src2,aaa:$src3)

Nested configuration flags:

Alignment options.

They can also be read as a whole for compatibility. The choices are:

None
Consecutive
AcrossEmptyLines
AcrossComments
AcrossEmptyLinesAndComments

For example, to align across empty lines and not across comments, eitherof these work.

AlignConsecutiveTableGenBreakingDAGArgColons:AcrossEmptyLinesAlignConsecutiveTableGenBreakingDAGArgColons:Enabled:trueAcrossEmptyLines:trueAcrossComments:false

boolEnabled Whether aligning is enabled.

#define SHORT_NAME       42#define LONGER_NAME      0x007f#define EVEN_LONGER_NAME (2)#define foo(x)           (x * x)#define bar(y, z)        (y + z)inta=1;intsomelongname=2;doublec=3;intaaaa:1;intb:12;intccc:8;intaaaa=12;floatb=23;std::stringccc;

boolAcrossEmptyLines Whether to align across empty lines.

true:inta=1;intsomelongname=2;doublec=3;intd=3;false:inta=1;intsomelongname=2;doublec=3;intd=3;

boolAcrossComments Whether to align across comments.

true:intd=3;/* A comment. */doublee=4;false:intd=3;/* A comment. */doublee=4;

boolAlignCompound Only forAlignConsecutiveAssignments. Whether compound assignmentslike+= are aligned along with=.
```
true:a&=2;bbb=2;false:a&=2;bbb=2;
```
boolAlignFunctionDeclarations Only forAlignConsecutiveDeclarations. Whether function declarationsare aligned.
```
true:unsignedintf1(void);voidf2(void);size_tf3(void);false:unsignedintf1(void);voidf2(void);size_tf3(void);
```
boolAlignFunctionPointers Only forAlignConsecutiveDeclarations. Whether function pointers arealigned.
```
true:unsignedi;int&r;int*p;int(*f)();false:unsignedi;int&r;int*p;int(*f)();
```
boolPadOperators Only forAlignConsecutiveAssignments. Whether short assignmentoperators are left-padded to the same length as long ones in order toput all assignment operators to the right of the left hand side.
```
true:a>>=2;bbb=2;a=2;bbb>>=2;false:a>>=2;bbb=2;a=2;bbb>>=2;
```

AlignConsecutiveTableGenCondOperatorColons (AlignConsecutiveStyle)clang-format 19¶

Style of aligning consecutive TableGen cond operator colons.Align the colons of cases inside !cond operators.

!cond(!eq(size,1):1,!eq(size,16):1,true:0)

Nested configuration flags:

Alignment options.

They can also be read as a whole for compatibility. The choices are:

None
Consecutive
AcrossEmptyLines
AcrossComments
AcrossEmptyLinesAndComments

For example, to align across empty lines and not across comments, eitherof these work.

AlignConsecutiveTableGenCondOperatorColons:AcrossEmptyLinesAlignConsecutiveTableGenCondOperatorColons:Enabled:trueAcrossEmptyLines:trueAcrossComments:false

boolEnabled Whether aligning is enabled.

#define SHORT_NAME       42#define LONGER_NAME      0x007f#define EVEN_LONGER_NAME (2)#define foo(x)           (x * x)#define bar(y, z)        (y + z)inta=1;intsomelongname=2;doublec=3;intaaaa:1;intb:12;intccc:8;intaaaa=12;floatb=23;std::stringccc;

boolAcrossEmptyLines Whether to align across empty lines.

true:inta=1;intsomelongname=2;doublec=3;intd=3;false:inta=1;intsomelongname=2;doublec=3;intd=3;

boolAcrossComments Whether to align across comments.

true:intd=3;/* A comment. */doublee=4;false:intd=3;/* A comment. */doublee=4;

boolAlignCompound Only forAlignConsecutiveAssignments. Whether compound assignmentslike+= are aligned along with=.
```
true:a&=2;bbb=2;false:a&=2;bbb=2;
```
boolAlignFunctionDeclarations Only forAlignConsecutiveDeclarations. Whether function declarationsare aligned.
```
true:unsignedintf1(void);voidf2(void);size_tf3(void);false:unsignedintf1(void);voidf2(void);size_tf3(void);
```
boolAlignFunctionPointers Only forAlignConsecutiveDeclarations. Whether function pointers arealigned.
```
true:unsignedi;int&r;int*p;int(*f)();false:unsignedi;int&r;int*p;int(*f)();
```
boolPadOperators Only forAlignConsecutiveAssignments. Whether short assignmentoperators are left-padded to the same length as long ones in order toput all assignment operators to the right of the left hand side.
```
true:a>>=2;bbb=2;a=2;bbb>>=2;false:a>>=2;bbb=2;a=2;bbb>>=2;
```

AlignConsecutiveTableGenDefinitionColons (AlignConsecutiveStyle)clang-format 19¶

Style of aligning consecutive TableGen definition colons.This aligns the inheritance colons of consecutive definitions.

defDef:Parent{}defDefDef:Parent{}defDefDefDef:Parent{}

Nested configuration flags:

Alignment options.

They can also be read as a whole for compatibility. The choices are:

None
Consecutive
AcrossEmptyLines
AcrossComments
AcrossEmptyLinesAndComments

For example, to align across empty lines and not across comments, eitherof these work.

AlignConsecutiveTableGenDefinitionColons:AcrossEmptyLinesAlignConsecutiveTableGenDefinitionColons:Enabled:trueAcrossEmptyLines:trueAcrossComments:false

boolEnabled Whether aligning is enabled.

#define SHORT_NAME       42#define LONGER_NAME      0x007f#define EVEN_LONGER_NAME (2)#define foo(x)           (x * x)#define bar(y, z)        (y + z)inta=1;intsomelongname=2;doublec=3;intaaaa:1;intb:12;intccc:8;intaaaa=12;floatb=23;std::stringccc;

boolAcrossEmptyLines Whether to align across empty lines.

true:inta=1;intsomelongname=2;doublec=3;intd=3;false:inta=1;intsomelongname=2;doublec=3;intd=3;

boolAcrossComments Whether to align across comments.

true:intd=3;/* A comment. */doublee=4;false:intd=3;/* A comment. */doublee=4;

boolAlignCompound Only forAlignConsecutiveAssignments. Whether compound assignmentslike+= are aligned along with=.
```
true:a&=2;bbb=2;false:a&=2;bbb=2;
```
boolAlignFunctionDeclarations Only forAlignConsecutiveDeclarations. Whether function declarationsare aligned.
```
true:unsignedintf1(void);voidf2(void);size_tf3(void);false:unsignedintf1(void);voidf2(void);size_tf3(void);
```
boolAlignFunctionPointers Only forAlignConsecutiveDeclarations. Whether function pointers arealigned.
```
true:unsignedi;int&r;int*p;int(*f)();false:unsignedi;int&r;int*p;int(*f)();
```
boolPadOperators Only forAlignConsecutiveAssignments. Whether short assignmentoperators are left-padded to the same length as long ones in order toput all assignment operators to the right of the left hand side.
```
true:a>>=2;bbb=2;a=2;bbb>>=2;false:a>>=2;bbb=2;a=2;bbb>>=2;
```

AlignEscapedNewlines (EscapedNewlineAlignmentStyle)clang-format 5¶

Options for aligning backslashes in escaped newlines.

Possible values:

ENAS_DontAlign (in configuration:DontAlign)Don’t align escaped newlines.
```
#define A \  int aaaa; \  int b; \  int dddddddddd;
```
ENAS_Left (in configuration:Left)Align escaped newlines as far left as possible.
```
#define A   \  int aaaa; \  int b;    \  int dddddddddd;
```
ENAS_LeftWithLastLine (in configuration:LeftWithLastLine)Align escaped newlines as far left as possible, using the last line ofthe preprocessor directive as the reference if it’s the longest.
```
#define A         \  int aaaa;       \  int b;          \  int dddddddddd;
```

ENAS_Right (in configuration:Right)Align escaped newlines in the right-most column.

#define A                                                            \  int aaaa;                                                          \  int b;                                                             \  int dddddddddd;

AlignOperands (OperandAlignmentStyle)clang-format 3.5¶

Iftrue, horizontally align operands of binary and ternaryexpressions.

Possible values:

OAS_DontAlign (in configuration:DontAlign)Do not align operands of binary and ternary expressions.The wrapped lines are indentedContinuationIndentWidth spaces fromthe start of the line.
OAS_Align (in configuration:Align)Horizontally align operands of binary and ternary expressions.
Specifically, this aligns operands of a single expression that needsto be split over multiple lines, e.g.:
```
intaaa=bbbbbbbbbbbbbbb+ccccccccccccccc;
```
WhenBreakBeforeBinaryOperators is set, the wrapped operator isaligned with the operand on the first line.
```
intaaa=bbbbbbbbbbbbbbb+ccccccccccccccc;
```
OAS_AlignAfterOperator (in configuration:AlignAfterOperator)Horizontally align operands of binary and ternary expressions.
This is similar toOAS_Align, except whenBreakBeforeBinaryOperators is set, the operator is un-indented sothat the wrapped operand is aligned with the operand on the first line.
```
intaaa=bbbbbbbbbbbbbbb+ccccccccccccccc;
```

AlignTrailingComments (TrailingCommentsAlignmentStyle)clang-format 3.7¶

Control of trailing comments.

The alignment stops at closing braces after a line break, and onlyfollowed by other closing braces, a (do-)while, a lambda call, ora semicolon.

Note

As of clang-format 16 this option is not a bool but can be setto the options. Conventional bool options still can be parsed as before.

# Example of usage:AlignTrailingComments:Kind:AlwaysOverEmptyLines:2

Nested configuration flags:

Alignment options

TrailingCommentsAlignmentKindsKindSpecifies the way to align trailing comments.
Possible values:
- TCAS_Leave (in configuration:Leave)Leave trailing comments as they are.
```
inta;// commentintab;// commentintabc;// commentintabcd;// comment
```
- TCAS_Always (in configuration:Always)Align trailing comments.
```
inta;// commentintab;// commentintabc;// commentintabcd;// comment
```
- TCAS_Never (in configuration:Never)Don’t align trailing comments but other formatter applies.
```
inta;// commentintab;// commentintabc;// commentintabcd;// comment
```
unsignedOverEmptyLines How many empty lines to apply alignment.When bothMaxEmptyLinesToKeep andOverEmptyLines are set to 2,it formats like below.
```
inta;// all theseintab;// comments areintabcdef;// aligned
```
WhenMaxEmptyLinesToKeep is set to 2 andOverEmptyLines is setto 1, it formats like below.
```
inta;// these areintab;// alignedintabcdef;// but this isn't
```

AllowAllArgumentsOnNextLine (Boolean)clang-format 9¶

If a function call or braced initializer list doesn’t fit on a line, allowputting all arguments onto the next line, even ifBinPackArguments isfalse.

true:callFunction(a,b,c,d);false:callFunction(a,b,c,d);

AllowAllConstructorInitializersOnNextLine (Boolean)clang-format 9¶: This option isdeprecated. SeeNextLine ofPackConstructorInitializers.

AllowAllParametersOfDeclarationOnNextLine (Boolean)clang-format 3.3¶

If the function declaration doesn’t fit on a line,allow putting all parameters of a function declaration ontothe next line even ifBinPackParameters isOnePerLine.

true:voidmyFunction(inta,intb,intc,intd,inte);false:voidmyFunction(inta,intb,intc,intd,inte);

AllowBreakBeforeNoexceptSpecifier (BreakBeforeNoexceptSpecifierStyle)clang-format 18¶

Controls if there could be a line break before anoexcept specifier.

Possible values:

BBNSS_Never (in configuration:Never)No line break allowed.

voidfoo(intarg1,doublearg2)noexcept;voidbar(intarg1,doublearg2)noexcept(noexcept(baz(arg1))&&noexcept(baz(arg2)));

BBNSS_OnlyWithParen (in configuration:OnlyWithParen)For a simplenoexcept there is no line break allowed, but when wehave a condition it is.
```
voidfoo(intarg1,doublearg2)noexcept;voidbar(intarg1,doublearg2)noexcept(noexcept(baz(arg1))&&noexcept(baz(arg2)));
```
BBNSS_Always (in configuration:Always)Line breaks are allowed. But note that because of the associatedpenaltiesclang-format often prefers not to break before thenoexcept.
```
voidfoo(intarg1,doublearg2)noexcept;voidbar(intarg1,doublearg2)noexcept(noexcept(baz(arg1))&&noexcept(baz(arg2)));
```

AllowShortBlocksOnASingleLine (ShortBlockStyle)clang-format 3.5¶

Dependent on the value,while(true){continue;} can be put on asingle line.

Possible values:

SBS_Never (in configuration:Never)Never merge blocks into a single line.
```
while(true){}while(true){continue;}
```
SBS_Empty (in configuration:Empty)Only merge empty blocks.
```
while(true){}while(true){continue;}
```
SBS_Always (in configuration:Always)Always merge short blocks into a single line.
```
while(true){}while(true){continue;}
```

AllowShortCaseExpressionOnASingleLine (Boolean)clang-format 19¶

Whether to merge a short switch labeled rule into a single line.

true:false:switch(a){vs.switch(a){case1->1;case1->default->0;1;};default->0;};

AllowShortCaseLabelsOnASingleLine (Boolean)clang-format 3.6¶

Iftrue, short case labels will be contracted to a single line.

true:false:switch(a){vs.switch(a){case1:x=1;break;case1:case2:return;x=1;}break;case2:return;}

AllowShortCompoundRequirementOnASingleLine (Boolean)clang-format 18¶

Allow short compound requirement on a single line.

true:template<typenameT>conceptc=requires(Tx){{x+1}->std::same_as<int>;};false:template<typenameT>conceptc=requires(Tx){{x+1}->std::same_as<int>;};

AllowShortEnumsOnASingleLine (Boolean)clang-format 11¶

Allow short enums on a single line.

true:enum{A,B}myEnum;false:enum{A,B}myEnum;

AllowShortFunctionsOnASingleLine (ShortFunctionStyle)clang-format 3.5¶

Dependent on the value,intf(){return0;} can be put on asingle line.

Possible values:

SFS_None (in configuration:None)Never merge functions into a single line.
SFS_InlineOnly (in configuration:InlineOnly)Only merge functions defined inside a class. Same asinline,except it does not impliesempty: i.e. top level empty functionsare not merged either.
```
classFoo{voidf(){foo();}};voidf(){foo();}voidf(){}
```
SFS_Empty (in configuration:Empty)Only merge empty functions.
```
voidf(){}voidf2(){bar2();}
```
SFS_Inline (in configuration:Inline)Only merge functions defined inside a class. Impliesempty.
```
classFoo{voidf(){foo();}};voidf(){foo();}voidf(){}
```
SFS_All (in configuration:All)Merge all functions fitting on a single line.
```
classFoo{voidf(){foo();}};voidf(){bar();}
```

AllowShortIfStatementsOnASingleLine (ShortIfStyle)clang-format 3.3¶

Dependent on the value,if(a)return; can be put on a single line.

Possible values:

SIS_Never (in configuration:Never)Never put short ifs on the same line.
```
if(a)return;if(b)return;elsereturn;if(c)return;else{return;}
```
SIS_WithoutElse (in configuration:WithoutElse)Put short ifs on the same line only if there is no else statement.
```
if(a)return;if(b)return;elsereturn;if(c)return;else{return;}
```
SIS_OnlyFirstIf (in configuration:OnlyFirstIf)Put short ifs, but not else ifs nor else statements, on the same line.
```
if(a)return;if(b)return;elseif(b)return;elsereturn;if(c)return;else{return;}
```
SIS_AllIfsAndElse (in configuration:AllIfsAndElse)Always put short ifs, else ifs and else statements on the sameline.
```
if(a)return;if(b)return;elsereturn;if(c)return;else{return;}
```

AllowShortLambdasOnASingleLine (ShortLambdaStyle)clang-format 9¶

Dependent on the value,autolambda[](){return0;} can be put on asingle line.

Possible values:

SLS_None (in configuration:None)Never merge lambdas into a single line.
SLS_Empty (in configuration:Empty)Only merge empty lambdas.
```
autolambda=[](inta){};autolambda2=[](inta){returna;};
```
SLS_Inline (in configuration:Inline)Merge lambda into a single line if the lambda is argument of a function.
```
autolambda=[](intx,inty){returnx<y;};sort(a.begin(),a.end(),[](intx,inty){returnx<y;});
```
SLS_All (in configuration:All)Merge all lambdas fitting on a single line.
```
autolambda=[](inta){};autolambda2=[](inta){returna;};
```

AllowShortLoopsOnASingleLine (Boolean)clang-format 3.7¶: Iftrue,while(true)continue; can be put on a singleline.

AllowShortNamespacesOnASingleLine (Boolean)clang-format 20¶: Iftrue,namespacea{classb;} can be put on a single line.

AlwaysBreakAfterDefinitionReturnType (DefinitionReturnTypeBreakingStyle)clang-format 3.7¶

The function definition return type breaking style to use. Thisoption isdeprecated and is retained for backwards compatibility.

Possible values:

DRTBS_None (in configuration:None)Break after return type automatically.PenaltyReturnTypeOnItsOwnLine is taken into account.
DRTBS_All (in configuration:All)Always break after the return type.
DRTBS_TopLevel (in configuration:TopLevel)Always break after the return types of top-level functions.

AlwaysBreakAfterReturnType (deprecated)clang-format 3.8¶: This option is renamed toBreakAfterReturnType.

AlwaysBreakBeforeMultilineStrings (Boolean)clang-format 3.4¶

Iftrue, always break before multiline string literals.

This flag is mean to make cases where there are multiple multiline stringsin a file look more consistent. Thus, it will only take effect if wrappingthe string at that point leads to it being indentedContinuationIndentWidth spaces from the start of the line.

true:false:aaaa=vs.aaaa="bbbb""bbbb""cccc";"cccc";

AlwaysBreakTemplateDeclarations (deprecated)clang-format 3.4¶: This option is renamed toBreakTemplateDeclarations.

AttributeMacros (ListofStrings)clang-format 12¶

A vector of strings that should be interpreted as attributes/qualifiersinstead of identifiers. This can be useful for language extensions orstatic analyzer annotations.

For example:

x=(char*__capability)&y;intfunction(void)__unused;voidonly_writes_to_buffer(char*__outputbuffer);

In the .clang-format configuration file, this can be configured like:

AttributeMacros:[__capability,__output,__unused]

BinPackArguments (Boolean)clang-format 3.7¶

Iffalse, a function call’s arguments will either be all on thesame line or will have one line each.

true:voidf(){f(aaaaaaaaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);}false:voidf(){f(aaaaaaaaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);}

BinPackLongBracedList (Boolean)clang-format 21¶

IfBinPackLongBracedList istrue it overridesBinPackArguments if there are 20 or more items in a bracedinitializer list.

BinPackLongBracedList:falsevs.BinPackLongBracedList:truevector<int>x{vector<int>x{1,2,...,20,21};1,2,...,20,21};

BinPackParameters (BinPackParametersStyle)clang-format 3.7¶

The bin pack parameters style to use.

Possible values:

BPPS_BinPack (in configuration:BinPack)Bin-pack parameters.

voidf(inta,intbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,intccccccccccccccccccccccccccccccccccccccccccc);

BPPS_OnePerLine (in configuration:OnePerLine)Put all parameters on the current line if they fit.Otherwise, put each one on its own line.
```
voidf(inta,intb,intc);voidf(inta,intb,intccccccccccccccccccccccccccccccccccccc);
```
BPPS_AlwaysOnePerLine (in configuration:AlwaysOnePerLine)Always put each parameter on its own line.
```
voidf(inta,intb,intc);
```

BitFieldColonSpacing (BitFieldColonSpacingStyle)clang-format 12¶

The BitFieldColonSpacingStyle to use for bitfields.

Possible values:

BFCS_Both (in configuration:Both)Add one space on each side of the:
```
unsignedbf:2;
```
BFCS_None (in configuration:None)Add no space around the: (except when needed forAlignConsecutiveBitFields).
```
unsignedbf:2;
```
BFCS_Before (in configuration:Before)Add space before the: only
```
unsignedbf:2;
```
BFCS_After (in configuration:After)Add space after the: only (space may be added before ifneeded forAlignConsecutiveBitFields).
```
unsignedbf:2;
```

BraceWrapping (BraceWrappingFlags)clang-format 3.8¶

Control of individual brace wrapping cases.

IfBreakBeforeBraces is set toCustom, use this to specify howeach individual brace case should be handled. Otherwise, this is ignored.

# Example of usage:BreakBeforeBraces:CustomBraceWrapping:AfterEnum:trueAfterStruct:falseSplitEmptyFunction:false

Nested configuration flags:

Precise control over the wrapping of braces.

# Should be declared this way:BreakBeforeBraces:CustomBraceWrapping:AfterClass:true

boolAfterCaseLabel Wrap case labels.

false:true:switch(foo){vs.switch(foo){case1:{case1:bar();{break;bar();}break;default:{}plop();default:}{}plop();}}

boolAfterClass Wrap class definitions.
```
true:classfoo{};false:classfoo{};
```
BraceWrappingAfterControlStatementStyleAfterControlStatementWrap control statements (if/for/while/switch/..).
Possible values:
- BWACS_Never (in configuration:Never)Never wrap braces after a control statement.
```
if(foo()){}else{}for(inti=0;i<10;++i){}
```
- BWACS_MultiLine (in configuration:MultiLine)Only wrap braces after a multi-line control statement.
```
if(foo&&bar&&baz){quux();}while(foo||bar){}
```
- BWACS_Always (in configuration:Always)Always wrap braces after a control statement.
```
if(foo()){}else{}for(inti=0;i<10;++i){}
```
boolAfterEnum Wrap enum definitions.
```
true:enumX:int{B};false:enumX:int{B};
```

boolAfterFunction Wrap function definitions.

true:voidfoo(){bar();bar2();}false:voidfoo(){bar();bar2();}

boolAfterNamespace Wrap namespace definitions.

true:namespace{intfoo();intbar();}false:namespace{intfoo();intbar();}

boolAfterObjCDeclaration Wrap ObjC definitions (interfaces, implementations…).
Note
@autoreleasepool and @synchronized blocks are wrappedaccording toAfterControlStatement flag.

boolAfterStruct Wrap struct definitions.

true:structfoo{intx;};false:structfoo{intx;};

boolAfterUnion Wrap union definitions.

true:unionfoo{intx;}false:unionfoo{intx;}

boolAfterExternBlock Wrap extern blocks.

true:extern"C"{intfoo();}false:extern"C"{intfoo();}

boolBeforeCatch Wrap beforecatch.

true:try{foo();}catch(){}false:try{foo();}catch(){}

boolBeforeElse Wrap beforeelse.

true:if(foo()){}else{}false:if(foo()){}else{}

boolBeforeLambdaBody Wrap lambda block.

true:connect([](){foo();bar();});false:connect([](){foo();bar();});

boolBeforeWhile Wrap beforewhile.

true:do{foo();}while(1);false:do{foo();}while(1);

boolIndentBraces Indent the wrapped braces themselves.
boolSplitEmptyFunction Iffalse, empty function body can be put on a single line.This option is used only if the opening brace of the function hasalready been wrapped, i.e. theAfterFunction brace wrapping mode isset, and the function could/should not be put on a single line (as perAllowShortFunctionsOnASingleLine and constructor formattingoptions).
```
false:true:intf()vs.intf(){}{}
```
boolSplitEmptyRecord Iffalse, empty record (e.g. class, struct or union) bodycan be put on a single line. This option is used only if the openingbrace of the record has already been wrapped, i.e. theAfterClass(for classes) brace wrapping mode is set.
```
false:true:classFoovs.classFoo{}{}
```
boolSplitEmptyNamespace Iffalse, empty namespace body can be put on a single line.This option is used only if the opening brace of the namespace hasalready been wrapped, i.e. theAfterNamespace brace wrapping mode isset.
```
false:true:namespaceFoovs.namespaceFoo{}{}
```

BracedInitializerIndentWidth (Integer)clang-format 17¶

The number of columns to use to indent the contents of braced init lists.If unset or negative,ContinuationIndentWidth is used.

AlignAfterOpenBracket:AlwaysBreakBracedInitializerIndentWidth:2voidf(){SomeClassc{"foo","bar","baz",};autos=SomeStruct{.foo="foo",.bar="bar",.baz="baz",};SomeArrayTa[3]={{foo,bar,},{foo,bar,},SomeArrayT{},};}

BreakAdjacentStringLiterals (Boolean)clang-format 18¶

Break between adjacent string literals.

true:return"Code""\0\52\26\55\55\0""x013""\02\xBA";false:return"Code""\0\52\26\55\55\0""x013""\02\xBA";

BreakAfterAttributes (AttributeBreakingStyle)clang-format 16¶

Break after a group of C++11 attributes before variable or function(including constructor/destructor) declaration/definition names or beforecontrol statements, i.e.if,switch (includingcase anddefault labels),for, andwhile statements.

Possible values:

ABS_Always (in configuration:Always)Always break after attributes.

[[maybe_unused]]constinti;[[gnu::const]][[maybe_unused]]intj;[[nodiscard]]inlineintf();[[gnu::const]][[nodiscard]]intg();[[likely]]if(a)f();elseg();switch(b){[[unlikely]]case1:++b;break;[[likely]]default:return;}

ABS_Leave (in configuration:Leave)Leave the line breaking after attributes as is.

[[maybe_unused]]constinti;[[gnu::const]][[maybe_unused]]intj;[[nodiscard]]inlineintf();[[gnu::const]][[nodiscard]]intg();[[likely]]if(a)f();elseg();switch(b){[[unlikely]]case1:++b;break;[[likely]]default:return;}

ABS_Never (in configuration:Never)Never break after attributes.

[[maybe_unused]]constinti;[[gnu::const]][[maybe_unused]]intj;[[nodiscard]]inlineintf();[[gnu::const]][[nodiscard]]intg();[[likely]]if(a)f();elseg();switch(b){[[unlikely]]case1:++b;break;[[likely]]default:return;}

BreakAfterJavaFieldAnnotations (Boolean)clang-format 3.8¶

Break after each annotation on a field in Java files.

true:false:@Partialvs.@Partial@MockDataLoadloader;@MockDataLoadloader;

BreakAfterReturnType (ReturnTypeBreakingStyle)clang-format 19¶

The function declaration return type breaking style to use.

Possible values:

RTBS_None (in configuration:None)This isdeprecated. SeeAutomatic below.
RTBS_Automatic (in configuration:Automatic)Break after return type based onPenaltyReturnTypeOnItsOwnLine.
```
classA{intf(){return0;};};intf();intf(){return1;}intLongName::AnotherLongName();
```
RTBS_ExceptShortType (in configuration:ExceptShortType)Same asAutomatic above, except that there is no break after shortreturn types.
```
classA{intf(){return0;};};intf();intf(){return1;}intLongName::AnotherLongName();
```

RTBS_All (in configuration:All)Always break after the return type.

classA{intf(){return0;};};intf();intf(){return1;}intLongName::AnotherLongName();

RTBS_TopLevel (in configuration:TopLevel)Always break after the return types of top-level functions.
```
classA{intf(){return0;};};intf();intf(){return1;}intLongName::AnotherLongName();
```
RTBS_AllDefinitions (in configuration:AllDefinitions)Always break after the return type of function definitions.
```
classA{intf(){return0;};};intf();intf(){return1;}intLongName::AnotherLongName();
```
RTBS_TopLevelDefinitions (in configuration:TopLevelDefinitions)Always break after the return type of top-level definitions.
```
classA{intf(){return0;};};intf();intf(){return1;}intLongName::AnotherLongName();
```

BreakArrays (Boolean)clang-format 16¶

Iftrue, clang-format will always break after a Json array[otherwise it will scan until the closing] to determine if it shouldadd newlines between elements (prettier compatible).

Note

This is currently only for formatting JSON.

true:false:[vs.[1,2,3,4]1,2,3,4]

BreakBeforeBinaryOperators (BinaryOperatorStyle)clang-format 3.6¶

The way to wrap binary operators.

Possible values:

BOS_None (in configuration:None)Break after operators.

LooooooooooongTypeloooooooooooooooooooooongVariable=someLooooooooooooooooongFunction();boolvalue=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa==aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa&&aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>ccccccccccccccccccccccccccccccccccccccccc;

BOS_NonAssignment (in configuration:NonAssignment)Break before operators that aren’t assignments.

LooooooooooongTypeloooooooooooooooooooooongVariable=someLooooooooooooooooongFunction();boolvalue=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa==aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa&&aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>ccccccccccccccccccccccccccccccccccccccccc;

BOS_All (in configuration:All)Break before operators.

LooooooooooongTypeloooooooooooooooooooooongVariable=someLooooooooooooooooongFunction();boolvalue=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa==aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa&&aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>ccccccccccccccccccccccccccccccccccccccccc;

BreakBeforeBraces (BraceBreakingStyle)clang-format 3.7¶

The brace breaking style to use.

Possible values:

BS_Attach (in configuration:Attach)Always attach braces to surrounding context.

namespaceN{enumE{E1,E2,};classC{public:C();};boolbaz(inti){try{do{switch(i){case1:{foobar();break;}default:{break;}}}while(--i);returntrue;}catch(...){handleError();returnfalse;}}voidfoo(boolb){if(b){baz(2);}else{baz(5);}}voidbar(){foo(true);}}// namespace N

BS_Linux (in configuration:Linux)LikeAttach, but break before braces on function, namespace andclass definitions.

namespaceN{enumE{E1,E2,};classC{public:C();};boolbaz(inti){try{do{switch(i){case1:{foobar();break;}default:{break;}}}while(--i);returntrue;}catch(...){handleError();returnfalse;}}voidfoo(boolb){if(b){baz(2);}else{baz(5);}}voidbar(){foo(true);}}// namespace N

BS_Mozilla (in configuration:Mozilla)LikeAttach, but break before braces on enum, function, and recorddefinitions.

namespaceN{enumE{E1,E2,};classC{public:C();};boolbaz(inti){try{do{switch(i){case1:{foobar();break;}default:{break;}}}while(--i);returntrue;}catch(...){handleError();returnfalse;}}voidfoo(boolb){if(b){baz(2);}else{baz(5);}}voidbar(){foo(true);}}// namespace N

BS_Stroustrup (in configuration:Stroustrup)LikeAttach, but break before function definitions,catch, andelse.

namespaceN{enumE{E1,E2,};classC{public:C();};boolbaz(inti){try{do{switch(i){case1:{foobar();break;}default:{break;}}}while(--i);returntrue;}catch(...){handleError();returnfalse;}}voidfoo(boolb){if(b){baz(2);}else{baz(5);}}voidbar(){foo(true);}}// namespace N

BS_Allman (in configuration:Allman)Always break before braces.

namespaceN{enumE{E1,E2,};classC{public:C();};boolbaz(inti){try{do{switch(i){case1:{foobar();break;}default:{break;}}}while(--i);returntrue;}catch(...){handleError();returnfalse;}}voidfoo(boolb){if(b){baz(2);}else{baz(5);}}voidbar(){foo(true);}}// namespace N

BS_Whitesmiths (in configuration:Whitesmiths)LikeAllman but always indent braces and line up code with braces.

namespaceN{enumE{E1,E2,};classC{public:C();};boolbaz(inti){try{do{switch(i){case1:{foobar();break;}default:{break;}}}while(--i);returntrue;}catch(...){handleError();returnfalse;}}voidfoo(boolb){if(b){baz(2);}else{baz(5);}}voidbar(){foo(true);}}// namespace N

BS_GNU (in configuration:GNU)Always break before braces and add an extra level of indentation tobraces of control statements, not to those of class, functionor other definitions.

namespaceN{enumE{E1,E2,};classC{public:C();};boolbaz(inti){try{do{switch(i){case1:{foobar();break;}default:{break;}}}while(--i);returntrue;}catch(...){handleError();returnfalse;}}voidfoo(boolb){if(b){baz(2);}else{baz(5);}}voidbar(){foo(true);}}// namespace N

BS_WebKit (in configuration:WebKit)LikeAttach, but break before functions.

namespaceN{enumE{E1,E2,};classC{public:C();};boolbaz(inti){try{do{switch(i){case1:{foobar();break;}default:{break;}}}while(--i);returntrue;}catch(...){handleError();returnfalse;}}voidfoo(boolb){if(b){baz(2);}else{baz(5);}}voidbar(){foo(true);}}// namespace N

BS_Custom (in configuration:Custom)Configure each individual brace inBraceWrapping.

BreakBeforeConceptDeclarations (BreakBeforeConceptDeclarationsStyle)clang-format 12¶

The concept declaration style to use.

Possible values:

BBCDS_Never (in configuration:Never)Keep the template declaration line together withconcept.
```
template<typenameT>conceptC=...;
```
BBCDS_Allowed (in configuration:Allowed)Breaking between template declaration andconcept is allowed. Theactual behavior depends on the content and line breaking rules andpenalties.
BBCDS_Always (in configuration:Always)Always break beforeconcept, putting it in the line after thetemplate declaration.
```
template<typenameT>conceptC=...;
```

BreakBeforeInlineASMColon (BreakBeforeInlineASMColonStyle)clang-format 16¶

The inline ASM colon style to use.

Possible values:

BBIAS_Never (in configuration:Never)No break before inline ASM colon.
```
asmvolatile("string",::val);
```
BBIAS_OnlyMultiline (in configuration:OnlyMultiline)Break before inline ASM colon if the line length is longer than columnlimit.
```
asmvolatile("string",::val);asm("cmoveq %1, %2, %[result]":[result]"=r"(result):"r"(test),"r"(new),"[result]"(old));
```
BBIAS_Always (in configuration:Always)Always break before inline ASM colon.
```
asmvolatile("string",::val);
```

BreakBeforeTemplateCloser (Boolean)clang-format 21¶

Iftrue, break before a template closing bracket (>) when there isa line break after the matching opening bracket (<).

true:template<typenameFoo,typenameBar>template<typenameFoo,typenameBar>template<typenameFoo,typenameBar>false:template<typenameFoo,typenameBar>template<typenameFoo,typenameBar>template<typenameFoo,typenameBar>

BreakBeforeTernaryOperators (Boolean)clang-format 3.7¶

Iftrue, ternary operators will be placed after line breaks.

true:veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription?firstValue:SecondValueVeryVeryVeryVeryLong;false:veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription?firstValue:SecondValueVeryVeryVeryVeryLong;

BreakBinaryOperations (BreakBinaryOperationsStyle)clang-format 20¶

The break binary operations style to use.

Possible values:

BBO_Never (in configuration:Never)Don’t break binary operations
```
aaa+bbbb*ccccc-ddddd+eeeeeeeeeeeeeeee;
```
BBO_OnePerLine (in configuration:OnePerLine)Binary operations will either be all on the same line, or each operationwill have one line each.
```
aaa+bbbb*ccccc-ddddd+eeeeeeeeeeeeeeee;
```
BBO_RespectPrecedence (in configuration:RespectPrecedence)Binary operations of a particular precedence that exceed the columnlimit will have one line each.
```
aaa+bbbb*ccccc-ddddd+eeeeeeeeeeeeeeee;
```

BreakConstructorInitializers (BreakConstructorInitializersStyle)clang-format 5¶

The break constructor initializers style to use.

Possible values:

BCIS_BeforeColon (in configuration:BeforeColon)Break constructor initializers before the colon and after the commas.
```
Constructor():initializer1(),initializer2()
```
BCIS_BeforeComma (in configuration:BeforeComma)Break constructor initializers before the colon and commas, and alignthe commas with the colon.
```
Constructor():initializer1(),initializer2()
```
BCIS_AfterColon (in configuration:AfterColon)Break constructor initializers after the colon and commas.
```
Constructor():initializer1(),initializer2()
```

BreakFunctionDefinitionParameters (Boolean)clang-format 19¶

Iftrue, clang-format will always break before function definitionparameters.

true:voidfunctionDefinition(intA,intB){}false:voidfunctionDefinition(intA,intB){}

BreakInheritanceList (BreakInheritanceListStyle)clang-format 7¶

The inheritance list style to use.

Possible values:

BILS_BeforeColon (in configuration:BeforeColon)Break inheritance list before the colon and after the commas.
```
classFoo:Base1,Base2{};
```
BILS_BeforeComma (in configuration:BeforeComma)Break inheritance list before the colon and commas, and alignthe commas with the colon.
```
classFoo:Base1,Base2{};
```
BILS_AfterColon (in configuration:AfterColon)Break inheritance list after the colon and commas.
```
classFoo:Base1,Base2{};
```
BILS_AfterComma (in configuration:AfterComma)Break inheritance list only after the commas.
```
classFoo:Base1,Base2{};
```

BreakStringLiterals (Boolean)clang-format 3.9¶

Allow breaking string literals when formatting.

In C, C++, and Objective-C:

true:constchar*x="veryVeryVeryVeryVeryVe""ryVeryVeryVeryVeryVery""VeryLongString";false:constchar*x="veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";

In C# and Java:

true:stringx="veryVeryVeryVeryVeryVe"+"ryVeryVeryVeryVeryVery"+"VeryLongString";false:stringx="veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";

C# interpolated strings are not broken.

In Verilog:

true:stringx={"veryVeryVeryVeryVeryVe","ryVeryVeryVeryVeryVery","VeryLongString"};false:stringx="veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";

BreakTemplateDeclarations (BreakTemplateDeclarationsStyle)clang-format 19¶

The template declaration breaking style to use.

Possible values:

BTDS_Leave (in configuration:Leave)Do not change the line breaking before the declaration.

template<typenameT>Tfoo(){}template<typenameT>Tfoo(intaaaaaaaaaaaaaaaaaaaaa,intbbbbbbbbbbbbbbbbbbbbb){}

BTDS_No (in configuration:No)Do not force break before declaration.PenaltyBreakTemplateDeclaration is taken into account.
```
template<typenameT>Tfoo(){}template<typenameT>Tfoo(intaaaaaaaaaaaaaaaaaaaaa,intbbbbbbbbbbbbbbbbbbbbb){}
```
BTDS_MultiLine (in configuration:MultiLine)Force break after template declaration only when the followingdeclaration spans multiple lines.
```
template<typenameT>Tfoo(){}template<typenameT>Tfoo(intaaaaaaaaaaaaaaaaaaaaa,intbbbbbbbbbbbbbbbbbbbbb){}
```

BTDS_Yes (in configuration:Yes)Always break after template declaration.

template<typenameT>Tfoo(){}template<typenameT>Tfoo(intaaaaaaaaaaaaaaaaaaaaa,intbbbbbbbbbbbbbbbbbbbbb){}

ColumnLimit (Unsigned)clang-format 3.7¶

The column limit.

A column limit of0 means that there is no column limit. In this case,clang-format will respect the input’s line breaking decisions withinstatements unless they contradict other rules.

CommentPragmas (String)clang-format 3.7¶

A regular expression that describes comments with special meaning,which should not be split into lines or otherwise changed.

// CommentPragmas: '^ FOOBAR pragma:'// Will leave the following line unaffected#include<vector> // FOOBAR pragma: keep

CompactNamespaces (Boolean)clang-format 5¶

Iftrue, consecutive namespace declarations will be on the sameline. Iffalse, each namespace is declared on a new line.

true:namespaceFoo{namespaceBar{}}false:namespaceFoo{namespaceBar{}}

If it does not fit on a single line, the overflowing namespaces getwrapped:

namespaceFoo{namespaceBar{namespaceExtra{}}}

ConstructorInitializerAllOnOneLineOrOnePerLine (Boolean)clang-format 3.7¶: This option isdeprecated. SeeCurrentLine ofPackConstructorInitializers.

ConstructorInitializerIndentWidth (Unsigned)clang-format 3.7¶: The number of characters to use for indentation of constructorinitializer lists as well as inheritance lists.

ContinuationIndentWidth (Unsigned)clang-format 3.7¶

Indent width for line continuations.

ContinuationIndentWidth:2inti=//  VeryVeryVeryVeryVeryLongCommentlongFunction(// Again a long commentarg);

Cpp11BracedListStyle (Boolean)clang-format 3.4¶

Iftrue, format braced lists as best suited for C++11 bracedlists.

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 functioncalls 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{} werethe parentheses of a function call with that name. If there is no name,a zero-length name is assumed.

true:false:vector<int>x{1,2,3,4};vs.vector<int>x{1,2,3,4};vector<T>x{{},{},{},{}};vector<T>x{{},{},{},{}};f(MyMap[{composite,key}]);f(MyMap[{composite,key}]);newint[3]{1,2,3};newint[3]{1,2,3};

DeriveLineEnding (Boolean)clang-format 10¶: This option isdeprecated. SeeDeriveLF andDeriveCRLF ofLineEnding.

DerivePointerAlignment (Boolean)clang-format 3.7¶: Iftrue, analyze the formatted file for the most commonalignment of& and*.Pointer and reference alignment styles are going to be updated accordingto the preferences found in the file.PointerAlignment is then used only as fallback.

DisableFormat (Boolean)clang-format 3.7¶: Disables formatting completely.

EmptyLineAfterAccessModifier (EmptyLineAfterAccessModifierStyle)clang-format 13¶

Defines when to put an empty line after access modifiers.EmptyLineBeforeAccessModifier configuration handles the number ofempty lines between two access modifiers.

Possible values:

ELAAMS_Never (in configuration:Never)Remove all empty lines after access modifiers.

structfoo{private:inti;protected:intj;/* comment */public:foo(){}private:protected:};

ELAAMS_Leave (in configuration:Leave)Keep existing empty lines after access modifiers.MaxEmptyLinesToKeep is applied instead.
ELAAMS_Always (in configuration:Always)Always add empty line after access modifiers if there are none.MaxEmptyLinesToKeep is applied also.
```
structfoo{private:inti;protected:intj;/* comment */public:foo(){}private:protected:};
```

EmptyLineBeforeAccessModifier (EmptyLineBeforeAccessModifierStyle)clang-format 12¶

Defines in which cases to put empty line before access modifiers.

Possible values:

ELBAMS_Never (in configuration:Never)Remove all empty lines before access modifiers.

structfoo{private:inti;protected:intj;/* comment */public:foo(){}private:protected:};

ELBAMS_Leave (in configuration:Leave)Keep existing empty lines before access modifiers.
ELBAMS_LogicalBlock (in configuration:LogicalBlock)Add empty line only when access modifier starts a new logical block.Logical block is a group of one or more member fields or functions.
```
structfoo{private:inti;protected:intj;/* comment */public:foo(){}private:protected:};
```
ELBAMS_Always (in configuration:Always)Always add empty line before access modifiers unless access modifieris at the start of struct or class definition.
```
structfoo{private:inti;protected:intj;/* comment */public:foo(){}private:protected:};
```

EnumTrailingComma (EnumTrailingCommaStyle)clang-format 21¶

Insert a comma (if missing) or remove the comma at the end of anenumenumerator list.

Warning

Setting this option to any value other thanLeave could lead toincorrect code formatting due to clang-format’s lack of complete semanticinformation. As such, extra care should be taken to review code changesmade by this option.

Possible values:

ETC_Leave (in configuration:Leave)Don’t insert or remove trailing commas.
```
enum{a,b,c,};enumColor{red,green,blue};
```
ETC_Insert (in configuration:Insert)Insert trailing commas.
```
enum{a,b,c,};enumColor{red,green,blue,};
```
ETC_Remove (in configuration:Remove)Remove trailing commas.
```
enum{a,b,c};enumColor{red,green,blue};
```

ExperimentalAutoDetectBinPacking (Boolean)clang-format 3.7¶

Iftrue, clang-format detects whether function calls anddefinitions are formatted with one parameter per line.

Each call can be bin-packed, one-per-line or inconclusive. If it isinconclusive, e.g. completely on one line, but a decision needs to bemade, clang-format analyzes whether there are other bin-packed cases inthe input file and act accordingly.

Note

This is an experimental flag, that might go away or be renamed. Donot use this in config files, etc. Use at your own risk.

FixNamespaceComments (Boolean)clang-format 5¶

Iftrue, clang-format adds missing namespace end comments fornamespaces and fixes invalid existing ones. This doesn’t affect shortnamespaces, which are controlled byShortNamespaceLines.

true:false:namespacelongNamespace{vs.namespacelongNamespace{voidfoo();voidfoo();voidbar();voidbar();}// namespace a                       }namespaceshortNamespace{namespaceshortNamespace{voidbaz();voidbaz();}}

ForEachMacros (ListofStrings)clang-format 3.7¶

A vector of macros that should be interpreted as foreach loopsinstead of as function calls.

These are expected to be macros of the form:

FOREACH(<variable-declaration>,...)<loop-body>

In the .clang-format configuration file, this can be configured like:

ForEachMacros:[RANGES_FOR,FOREACH]

For example: BOOST_FOREACH.

IfMacros (ListofStrings)clang-format 13¶

A vector of macros that should be interpreted as conditionalsinstead of as function calls.

These are expected to be macros of the form:

IF(...)<conditional-body>elseIF(...)<conditional-body>

In the .clang-format configuration file, this can be configured like:

IfMacros:[IF]

For example:KJ_IF_MAYBE

IncludeBlocks (IncludeBlocksStyle)clang-format 6¶

Dependent on the value, multiple#include blocks can be sortedas one and divided based on category.

Possible values:

IBS_Preserve (in configuration:Preserve)Sort each#include block separately.

#include"b.h"               into      #include "b.h"#include<lib/main.h>                  #include "a.h"#include"a.h"                         #include <lib/main.h>

IBS_Merge (in configuration:Merge)Merge multiple#include blocks together and sort as one.

#include"b.h"               into      #include "a.h"#include"b.h"#include<lib/main.h>                  #include <lib/main.h>#include"a.h"

IBS_Regroup (in configuration:Regroup)Merge multiple#include blocks together and sort as one.Then split into groups based on category priority. SeeIncludeCategories.

#include"b.h"               into      #include "a.h"#include"b.h"#include<lib/main.h>#include"a.h"                         #include <lib/main.h>

IncludeCategories (ListofIncludeCategories)clang-format 3.8¶

Regular expressions denoting the different#include categoriesused for ordering#includes.

POSIX extendedregular expressions are supported.

These regular expressions are matched against the filename of an include(including the <> or “”) in order. The value belonging to the firstmatching regular expression is assigned and#includes are sorted firstaccording to increasing category number and then alphabetically withineach category.

If none of the regular expressions match, INT_MAX is assigned ascategory. The main header for a source file automatically gets category 0.so that it is generally kept at the beginning of the#includes(https://llvm.org/docs/CodingStandards.html#include-style). However, youcan also assign negative priorities if you have certain headers thatalways need to be first.

There is a third and optional fieldSortPriority which can used whileIncludeBlocks=IBS_Regroup to define the priority in which#includes should be ordered. The value ofPriority defines theorder of#includeblocks and also allows the grouping of#includesof different priority.SortPriority is set to the value ofPriority as default if it is not assigned.

Each regular expression can be marked as case sensitive with the fieldCaseSensitive, per default it is not.

To configure this in the .clang-format file, use:

IncludeCategories:-Regex:'^"(llvm|llvm-c|clang|clang-c)/'Priority:2SortPriority:2CaseSensitive:true-Regex:'^((<|")(gtest|gmock|isl|json)/)'Priority:3-Regex:'<[[:alnum:].]+>'Priority:4-Regex:'.*'Priority:1SortPriority:0

IncludeIsMainRegex (String)clang-format 3.9¶

Specify a regular expression of suffixes that are allowed in thefile-to-main-include mapping.

When guessing whether a #include is the “main” include (to assigncategory 0, see above), use this regex of allowed suffixes to the headerstem. 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 seenas the “main” include in both a.cc and a_test.cc.

IncludeIsMainSourceRegex (String)clang-format 10¶

Specify a regular expression for files being formattedthat are allowed to be considered “main” in thefile-to-main-include mapping.

By default, clang-format considers files as “main” only when they endwith:.c,.cc,.cpp,.c++,.cxx,.m or.mmextensions.For these files a guessing of “main” include takes place(to assign category 0, see above). This config option allows foradditional suffixes and extensions for files to be considered as “main”.

For example, if this option is configured to(Impl\.hpp)$,then a fileClassImpl.hpp is considered “main” (in addition toClass.c,Class.cc,Class.cpp and so on) and “maininclude file” logic will be executed (withIncludeIsMainRegex settingalso being respected in later phase). Without this option set,ClassImpl.hpp would not have the main include file put on topbefore any other include.

IndentAccessModifiers (Boolean)clang-format 13¶

Specify whether access modifiers should have their own indentation level.

Whenfalse, access modifiers are indented (or outdented) relative tothe record members, respecting theAccessModifierOffset. Recordmembers are indented one level below the record.Whentrue, access modifiers get their own indentation level. As aconsequence, record members are always indented 2 levels below the record,regardless of the access modifier presence. Value of theAccessModifierOffset is ignored.

false:true:classC{vs.classC{classD{classD{voidbar();voidbar();protected:protected:D();D();};};public:public:C();C();};};voidfoo(){voidfoo(){return1;return1;}}

IndentCaseBlocks (Boolean)clang-format 11¶

Indent case label blocks one level from the case label.

Whenfalse, the block following the case label uses the sameindentation level as for the case label, treating the case label the sameas an if-statement.Whentrue, the block gets indented as a scope block.

false:true:switch(fool){vs.switch(fool){case1:{case1:bar();{}break;bar();default:{}plop();break;}default:}{plop();}}

IndentCaseLabels (Boolean)clang-format 3.3¶

Indent case labels one level from the switch statement.

Whenfalse, use the same indentation level as for the switchstatement. Switch statement body is always indented one level more thancase labels (except the first block following the case label, whichitself indents the code - unless IndentCaseBlocks is enabled).

false:true:switch(fool){vs.switch(fool){case1:case1:bar();bar();break;break;default:default:plop();plop();}}

IndentExportBlock (Boolean)clang-format 20¶

Iftrue, clang-format will indent the body of anexport{...}block. This doesn’t affect the formatting of anything else related toexported declarations.

true:false:export{vs.export{voidfoo();voidfoo();voidbar();voidbar();}}

IndentExternBlock (IndentExternBlockStyle)clang-format 11¶

IndentExternBlockStyle is the type of indenting of extern blocks.

Possible values:

IEBS_AfterExternBlock (in configuration:AfterExternBlock)Backwards compatible with AfterExternBlock’s indenting.

IndentExternBlock:AfterExternBlockBraceWrapping.AfterExternBlock:trueextern"C"{voidfoo();}

IndentExternBlock:AfterExternBlockBraceWrapping.AfterExternBlock:falseextern"C"{voidfoo();}

IEBS_NoIndent (in configuration:NoIndent)Does not indent extern blocks.
```
extern"C"{voidfoo();}
```
IEBS_Indent (in configuration:Indent)Indents extern blocks.
```
extern"C"{voidfoo();}
```

IndentGotoLabels (Boolean)clang-format 10¶

Indent goto labels.

Whenfalse, goto labels are flushed left.

true:false:intf(){vs.intf(){if(foo()){if(foo()){label1:label1:bar();bar();}}label2:label2:return1;return1;}}

IndentPPDirectives (PPDirectiveIndentStyle)clang-format 6¶

The preprocessor directive indenting style to use.

Possible values:

PPDIS_None (in configuration:None)Does not indent any directives.
```
#if FOO#if BAR#include<foo>#endif#endif
```
PPDIS_AfterHash (in configuration:AfterHash)Indents directives after the hash.
```
#if FOO#  if BAR#include<foo>#  endif#endif
```
PPDIS_BeforeHash (in configuration:BeforeHash)Indents directives before the hash.
```
#if FOO#if BAR#include<foo>#endif#endif
```

IndentRequiresClause (Boolean)clang-format 15¶

Indent the requires clause in a template. This only applies whenRequiresClausePosition isOwnLine,OwnLineWithBrace,orWithFollowing.

In clang-format 12, 13 and 14 it was namedIndentRequires.

true:template<typenameIt>requiresIterator<It>voidsort(Itbegin,Itend){//....}false:template<typenameIt>requiresIterator<It>voidsort(Itbegin,Itend){//....}

IndentWidth (Unsigned)clang-format 3.7¶

The number of columns to use for indentation.

IndentWidth:3voidf(){someFunction();if(true,false){f();}}

IndentWrappedFunctionNames (Boolean)clang-format 3.7¶

Indent if a function definition or declaration is wrapped after thetype.

true:LoooooooooooooooooooooooooooooooooooooooongReturnTypeLoooooooooooooooooooooooooooooooongFunctionDeclaration();false:LoooooooooooooooooooooooooooooooooooooooongReturnTypeLoooooooooooooooooooooooooooooooongFunctionDeclaration();

InsertBraces (Boolean)clang-format 15¶

Insert braces after control statements (if,else,for,do,andwhile) in C++ unless the control statements are inside macrodefinitions or the braces would enclose preprocessor directives.

Warning

Setting this option totrue could lead to incorrect code formattingdue to clang-format’s lack of complete semantic information. As such,extra care should be taken to review code changes made by this option.

false:true:if(isa<FunctionDecl>(D))vs.if(isa<FunctionDecl>(D)){handleFunctionDecl(D);handleFunctionDecl(D);elseif(isa<VarDecl>(D))}elseif(isa<VarDecl>(D)){handleVarDecl(D);handleVarDecl(D);else}else{return;return;}while(i--)vs.while(i--){for(auto*A:D.attrs())for(auto*A:D.attrs()){handleAttr(A);handleAttr(A);}}dovs.do{--i;--i;while(i);}while(i);

InsertNewlineAtEOF (Boolean)clang-format 16¶: Insert a newline at end of file if missing.

InsertTrailingCommas (TrailingCommaStyle)clang-format 11¶

If set toTCS_Wrapped will insert trailing commas in containerliterals (arrays and objects) that wrap across multiple lines.It is currently only available for JavaScriptand disabled by defaultTCS_None.InsertTrailingCommas cannot be used together withBinPackArgumentsas inserting the comma disables bin-packing.

TSC_Wrapped:constsomeArray=[aaaaaaaaaaaaaaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaaaaaaaa,//                        ^ inserted]

Possible values:

TCS_None (in configuration:None)Do not insert trailing commas.
TCS_Wrapped (in configuration:Wrapped)Insert trailing commas in container literals that were wrapped overmultiple lines. Note that this is conceptually incompatible withbin-packing, because the trailing comma is used as an indicatorthat a container should be formatted one-per-line (i.e. not bin-packed).So inserting a trailing comma counteracts bin-packing.

IntegerLiteralSeparator (IntegerLiteralSeparatorStyle)clang-format 16¶

Format integer literal separators (' for C++ and_ for C#, Java,and JavaScript).

Nested configuration flags:

Separator format of integer literals of different bases.

If negative, remove separators. If0, leave the literal as is. Ifpositive, insert separators between digits starting from the rightmostdigit.

For example, the config below will leave separators in binary literalsalone, insert separators in decimal literals to separate the digits intogroups of 3, and remove separators in hexadecimal literals.

IntegerLiteralSeparator:Binary:0Decimal:3Hex:-1

You can also specify a minimum number of digits (BinaryMinDigits,DecimalMinDigits, andHexMinDigits) the integer literal musthave in order for the separators to be inserted.

int8_tBinary Format separators in binary literals.

/* -1: */ b = 0b100111101101;/*  0: */ b = 0b10011'11'0110'1;/*  3: */ b = 0b100'111'101'101;/*  4: */ b = 0b1001'1110'1101;

int8_tBinaryMinDigits Format separators in binary literals with a minimum number of digits.
```
// Binary: 3// BinaryMinDigits: 7b1 = 0b101101;b2 = 0b1'101'101;
```

int8_tDecimal Format separators in decimal literals.

/* -1: */ d = 18446744073709550592ull;/*  0: */ d = 184467'440737'0'95505'92ull;/*  3: */ d = 18'446'744'073'709'550'592ull;

int8_tDecimalMinDigits Format separators in decimal literals with a minimum number of digits.
```
// Decimal: 3// DecimalMinDigits: 5d1 = 2023;d2 = 10'000;
```

int8_tHex Format separators in hexadecimal literals.

/* -1: */ h = 0xDEADBEEFDEADBEEFuz;/*  0: */ h = 0xDEAD'BEEF'DE'AD'BEE'Fuz;/*  2: */ h = 0xDE'AD'BE'EF'DE'AD'BE'EFuz;

int8_tHexMinDigits Format separators in hexadecimal literals with a minimum number ofdigits.
```
// Hex: 2// HexMinDigits: 6h1 = 0xABCDE;h2 = 0xAB'CD'EF;
```

JavaImportGroups (ListofStrings)clang-format 8¶

A vector of prefixes ordered by the desired groups for Java imports.

One group’s prefix can be a subset of another - the longest prefix isalways matched. Within a group, the imports are ordered lexicographically.Static imports are grouped separately and follow the same group rules.By default, static imports are placed before non-static imports,but this behavior is changed by another option,SortJavaStaticImport.

In the .clang-format configuration file, this can be configured likein the following yaml example. This will result in imports beingformatted as in the Java example below.

JavaImportGroups:[com.example,com,org]

import staticcom.example.function1;import staticcom.test.function2;import staticorg.example.function3;importcom.example.ClassA;importcom.example.Test;importcom.example.a.ClassB;importcom.test.ClassC;importorg.example.ClassD;

JavaScriptQuotes (JavaScriptQuoteStyle)clang-format 3.9¶

The JavaScriptQuoteStyle to use for JavaScript strings.

Possible values:

JSQS_Leave (in configuration:Leave)Leave string quotes as they are.
```
string1="foo";string2='bar';
```
JSQS_Single (in configuration:Single)Always use single quotes.
```
string1='foo';string2='bar';
```
JSQS_Double (in configuration:Double)Always use double quotes.
```
string1="foo";string2="bar";
```

JavaScriptWrapImports (Boolean)clang-format 3.9¶

Whether to wrap JavaScript import/export statements.

true:import{VeryLongImportsAreAnnoying,VeryLongImportsAreAnnoying,VeryLongImportsAreAnnoying,}from"some/module.js"false:import{VeryLongImportsAreAnnoying,VeryLongImportsAreAnnoying,VeryLongImportsAreAnnoying,}from"some/module.js"

KeepEmptyLines (KeepEmptyLinesStyle)clang-format 19¶

Which empty lines are kept. SeeMaxEmptyLinesToKeep for how manyconsecutive empty lines are kept.

Nested configuration flags:

Options regarding which empty lines are kept.

For example, the config below will remove empty lines at start of thefile, end of the file, and start of blocks.

KeepEmptyLines:AtEndOfFile:falseAtStartOfBlock:falseAtStartOfFile:false

boolAtEndOfFile Keep empty lines at end of file.
boolAtStartOfBlock Keep empty lines at start of a block.
```
true:false:if(foo){vs.if(foo){bar();bar();}}
```
boolAtStartOfFile Keep empty lines at start of file.

KeepEmptyLinesAtEOF (Boolean)clang-format 17¶: This option isdeprecated. SeeAtEndOfFile ofKeepEmptyLines.

KeepEmptyLinesAtTheStartOfBlocks (Boolean)clang-format 3.7¶: This option isdeprecated. SeeAtStartOfBlock ofKeepEmptyLines.

KeepFormFeed (Boolean)clang-format 20¶: Keep the form feed character if it’s immediately preceded and followed bya newline. Multiple form feeds and newlines within a whitespace range arereplaced with a single newline and form feed followed by the remainingnewlines.

LambdaBodyIndentation (LambdaBodyIndentationKind)clang-format 13¶

The indentation style of lambda bodies.Signature (the default)causes the lambda body to be indented one additional level relative tothe indentation level of the signature.OuterScope forces the lambdabody to be indented one additional level relative to the parent scopecontaining the lambda signature.

Possible values:

LBI_Signature (in configuration:Signature)Align lambda body relative to the lambda signature. This is the default.
```
someMethod([](SomeReallyLongLambdaSignatureArgumentfoo){return;});
```
LBI_OuterScope (in configuration:OuterScope)For statements within block scope, align lambda body relative to theindentation level of the outer scope the lambda signature resides in.
```
someMethod([](SomeReallyLongLambdaSignatureArgumentfoo){return;});someMethod(someOtherMethod([](SomeReallyLongLambdaSignatureArgumentfoo){return;}));
```

Language (LanguageKind)clang-format 3.5¶

The language that this format style targets.

Note

You can specify the language (C,Cpp, orObjC) for.hfiles by adding a//clang-formatLanguage: line before the firstnon-comment (and non-empty) line, e.g.//clang-formatLanguage:Cpp.

Possible values:

LK_None (in configuration:None)Do not use.
LK_C (in configuration:C)Should be used for C.
LK_Cpp (in configuration:Cpp)Should be used for C++.
LK_CSharp (in configuration:CSharp)Should be used for C#.
LK_Java (in configuration:Java)Should be used for Java.
LK_JavaScript (in configuration:JavaScript)Should be used for JavaScript.
LK_Json (in configuration:Json)Should be used for JSON.
LK_ObjC (in configuration:ObjC)Should be used for Objective-C, Objective-C++.
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.
LK_TextProto (in configuration:TextProto)Should be used for Protocol Buffer messages in text format(https://developers.google.com/protocol-buffers/).
LK_Verilog (in configuration:Verilog)Should be used for Verilog and SystemVerilog.https://standards.ieee.org/ieee/1800/6700/https://sci-hub.st/10.1109/IEEESTD.2018.8299595

LineEnding (LineEndingStyle)clang-format 16¶

Line ending style (\n or\r\n) to use.

Possible values:

LE_LF (in configuration:LF)Use\n.
LE_CRLF (in configuration:CRLF)Use\r\n.
LE_DeriveLF (in configuration:DeriveLF)Use\n unless the input has more lines ending in\r\n.
LE_DeriveCRLF (in configuration:DeriveCRLF)Use\r\n unless the input has more lines ending in\n.

MacroBlockBegin (String)clang-format 3.7¶

A regular expression matching macros that start a block.

# With:MacroBlockBegin:"^NS_MAP_BEGIN|\NS_TABLE_HEAD$"MacroBlockEnd:"^\NS_MAP_END|\NS_TABLE_.*_END$"NS_MAP_BEGINfoo();NS_MAP_ENDNS_TABLE_HEADbar();NS_TABLE_FOO_END# Without:NS_MAP_BEGINfoo();NS_MAP_ENDNS_TABLE_HEADbar();NS_TABLE_FOO_END

MacroBlockEnd (String)clang-format 3.7¶: A regular expression matching macros that end a block.

Macros (ListofStrings)clang-format 17¶

A list of macros of the form<definition>=<expansion> .

Code will be parsed with macros expanded, in order to determine how tointerpret and format the macro arguments.

For example, the code:

A(a*b);

will usually be interpreted as a call to a function A, and themultiplication expression will be formatted asa*b.

If we specify the macro definition:

Macros:-A(x)=x

the code will now be parsed as a declaration of the variable b of type a*,and formatted asa*b (depending on pointer-binding rules).

Features and restrictions:

Both function-like macros and object-like macros are supported.
Macro arguments must be used exactly once in the expansion.
No recursive expansion; macros referencing other macros will beignored.
Overloading by arity is supported: for example, given the macrodefinitions A=x, A()=y, A(a)=a

A;->x;A();->y;A(z);->z;A(a,b);// will not be expanded.

MacrosSkippedByRemoveParentheses (ListofStrings)clang-format 21¶: A vector of function-like macros whose invocations should be skipped byRemoveParentheses.

MainIncludeChar (MainIncludeCharDiscriminator)clang-format 19¶

When guessing whether a #include is the “main” include, only the includedirectives that use the specified character are considered.

Possible values:

MICD_Quote (in configuration:Quote)Main include uses quotes:#include"foo.hpp" (the default).
MICD_AngleBracket (in configuration:AngleBracket)Main include uses angle brackets:#include<foo.hpp>.
MICD_Any (in configuration:Any)Main include uses either quotes or angle brackets.

MaxEmptyLinesToKeep (Unsigned)clang-format 3.7¶

The maximum number of consecutive empty lines to keep.

MaxEmptyLinesToKeep:1vs.MaxEmptyLinesToKeep:0intf(){intf(){int=1;inti=1;i=foo();i=foo();returni;}returni;}

NamespaceIndentation (NamespaceIndentationKind)clang-format 3.7¶

The indentation used for namespaces.

Possible values:

NI_None (in configuration:None)Don’t indent in namespaces.
```
namespaceout{inti;namespacein{inti;}}
```
NI_Inner (in configuration:Inner)Indent only in inner namespaces (nested in other namespaces).
```
namespaceout{inti;namespacein{inti;}}
```
NI_All (in configuration:All)Indent in all namespaces.
```
namespaceout{inti;namespacein{inti;}}
```

NamespaceMacros (ListofStrings)clang-format 9¶

A vector of macros which are used to open namespace blocks.

These are expected to be macros of the form:

NAMESPACE(<namespace-name>,...){<namespace-content>}

For example: TESTSUITE

ObjCBinPackProtocolList (BinPackStyle)clang-format 7¶

Controls bin-packing Objective-C protocol conformance listitems into as few lines as possible when they go overColumnLimit.

IfAuto (the default), delegates to the value inBinPackParameters. If that isBinPack, bin-packs Objective-Cprotocol conformance list items into as few lines as possiblewhenever they go overColumnLimit.

IfAlways, always bin-packs Objective-C protocol conformancelist items into as few lines as possible whenever they go overColumnLimit.

IfNever, lays out Objective-C protocol conformance list itemsonto individual lines whenever they go overColumnLimit.

Always(orAuto,ifBinPackParameters==BinPack):@interfaceccccccccccccc()<ccccccccccccc,ccccccccccccc,ccccccccccccc,ccccccccccccc>{}Never(orAuto,ifBinPackParameters!=BinPack):@interfaceddddddddddddd()<ddddddddddddd,ddddddddddddd,ddddddddddddd,ddddddddddddd>{}

Possible values:

BPS_Auto (in configuration:Auto)Automatically determine parameter bin-packing behavior.
BPS_Always (in configuration:Always)Always bin-pack parameters.
BPS_Never (in configuration:Never)Never bin-pack parameters.

ObjCBlockIndentWidth (Unsigned)clang-format 3.7¶

The number of characters to use for indentation of ObjC blocks.

ObjCBlockIndentWidth:4[operationsetCompletionBlock:^{[selfonOperationDone];}];

ObjCBreakBeforeNestedBlockParam (Boolean)clang-format 11¶

Break parameters list into lines when there is nested blockparameters in a function call.

false:-(void)_aMethod{[self.test1t:selfw:selfcallback:^(typeof(self)self,NSNumber*u,NSNumber*v){u=c;}]}true:-(void)_aMethod{[self.test1t:selfw:selfcallback:^(typeof(self)self,NSNumber*u,NSNumber*v){u=c;}]}

ObjCPropertyAttributeOrder (ListofStrings)clang-format 18¶

The order in which ObjC property attributes should appear.

Attributes in code will be sorted in the order specified. Any attributesencountered that are not mentioned in this array will be sorted last, instable order. Comments between attributes will leave the attributesuntouched.

Warning

Using this option could lead to incorrect code formatting due toclang-format’s lack of complete semantic information. As such, extracare should be taken to review code changes made by this option.

ObjCPropertyAttributeOrder:[class,direct,atomic,nonatomic,assign,retain,strong,copy,weak,unsafe_unretained,readonly,readwrite,getter,setter,nullable,nonnull,null_resettable,null_unspecified]

ObjCSpaceAfterProperty (Boolean)clang-format 3.7¶: Add a space after@property in Objective-C, i.e. use@property(readonly) instead of@property(readonly).

ObjCSpaceBeforeProtocolList (Boolean)clang-format 3.7¶: Add a space in front of an Objective-C protocol list, i.e. useFoo<Protocol> instead ofFoo<Protocol>.

OneLineFormatOffRegex (String)clang-format 21¶

A regular expression that describes markers for turning formatting off forone line. If it matches a comment that is the only token of a line,clang-format skips the comment and the next line. Otherwise, clang-formatskips lines containing a matched token.

// OneLineFormatOffRegex: ^(// NOLINT|logger$)// results in the output below:inta;intb;// NOLINTintc;// NOLINTNEXTLINEintd;inte;s="// NOLINT";logger();logger2();my_logger();

PPIndentWidth (Integer)clang-format 13¶

The number of columns to use for indentation of preprocessor statements.When set to -1 (default)IndentWidth is used also for preprocessorstatements.

PPIndentWidth:1#ifdef __linux__# define FOO#else# define BAR#endif

PackConstructorInitializers (PackConstructorInitializersStyle)clang-format 14¶

The pack constructor initializers style to use.

Possible values:

PCIS_Never (in configuration:Never)Always put each constructor initializer on its own line.
```
Constructor():a(),b()
```

PCIS_BinPack (in configuration:BinPack)Bin-pack constructor initializers.

Constructor():aaaaaaaaaaaaaaaaaaaa(),bbbbbbbbbbbbbbbbbbbb(),cccccccccccccccccccc()

PCIS_CurrentLine (in configuration:CurrentLine)Put all constructor initializers on the current line if they fit.Otherwise, put each one on its own line.
```
Constructor():a(),b()Constructor():aaaaaaaaaaaaaaaaaaaa(),bbbbbbbbbbbbbbbbbbbb(),ddddddddddddd()
```

PCIS_NextLine (in configuration:NextLine)Same asPCIS_CurrentLine except that if all constructor initializersdo not fit on the current line, try to fit them on the next line.

Constructor():a(),b()Constructor():aaaaaaaaaaaaaaaaaaaa(),bbbbbbbbbbbbbbbbbbbb(),ddddddddddddd()Constructor():aaaaaaaaaaaaaaaaaaaa(),bbbbbbbbbbbbbbbbbbbb(),cccccccccccccccccccc()

PCIS_NextLineOnly (in configuration:NextLineOnly)Put all constructor initializers on the next line if they fit.Otherwise, put each one on its own line.

Constructor():a(),b()Constructor():aaaaaaaaaaaaaaaaaaaa(),bbbbbbbbbbbbbbbbbbbb(),ddddddddddddd()Constructor():aaaaaaaaaaaaaaaaaaaa(),bbbbbbbbbbbbbbbbbbbb(),cccccccccccccccccccc()

PenaltyBreakAssignment (Unsigned)clang-format 5¶: The penalty for breaking around an assignment operator.

PenaltyBreakBeforeFirstCallParameter (Unsigned)clang-format 3.7¶: The penalty for breaking a function call aftercall(.

PenaltyBreakBeforeMemberAccess (Unsigned)clang-format 20¶: The penalty for breaking before a member access operator (.,->).

PenaltyBreakComment (Unsigned)clang-format 3.7¶: The penalty for each line break introduced inside a comment.

PenaltyBreakFirstLessLess (Unsigned)clang-format 3.7¶: The penalty for breaking before the first<<.

PenaltyBreakOpenParenthesis (Unsigned)clang-format 14¶: The penalty for breaking after(.

PenaltyBreakScopeResolution (Unsigned)clang-format 18¶: The penalty for breaking after::.

PenaltyBreakString (Unsigned)clang-format 3.7¶: The penalty for each line break introduced inside a string literal.

PenaltyBreakTemplateDeclaration (Unsigned)clang-format 7¶: The penalty for breaking after template declaration.

PenaltyExcessCharacter (Unsigned)clang-format 3.7¶: The penalty for each character outside of the column limit.

PenaltyIndentedWhitespace (Unsigned)clang-format 12¶: Penalty for each character of whitespace indentation(counted relative to leading non-whitespace column).

PenaltyReturnTypeOnItsOwnLine (Unsigned)clang-format 3.7¶: Penalty for putting the return type of a function onto its own line.

PointerAlignment (PointerAlignmentStyle)clang-format 3.7¶

Pointer and reference alignment style.

Possible values:

PAS_Left (in configuration:Left)Align pointer to the left.
```
int*a;
```
PAS_Right (in configuration:Right)Align pointer to the right.
```
int*a;
```
PAS_Middle (in configuration:Middle)Align pointer in the middle.
```
int*a;
```

QualifierAlignment (QualifierAlignmentStyle)clang-format 14¶

Different ways to arrange specifiers and qualifiers (e.g. const/volatile).

Warning

SettingQualifierAlignment to something other thanLeave, COULDlead to incorrect code formatting due to incorrect decisions made due toclang-formats lack of complete semantic information.As such extra care should be taken to review code changes made by the useof this option.

Possible values:

QAS_Leave (in configuration:Leave)Don’t change specifiers/qualifiers to either Left or Right alignment(default).
```
intconsta;constint*a;
```
QAS_Left (in configuration:Left)Change specifiers/qualifiers to be left-aligned.
```
constinta;constint*a;
```
QAS_Right (in configuration:Right)Change specifiers/qualifiers to be right-aligned.
```
intconsta;intconst*a;
```
QAS_Custom (in configuration:Custom)Change specifiers/qualifiers to be aligned based onQualifierOrder.With:
```
QualifierOrder:[inline,static,type,const]
```
```
intconsta;intconst*a;
```

QualifierOrder (ListofStrings)clang-format 14¶

The order in which the qualifiers appear.The order is an array that can contain any of the following:

const
inline
static
friend
constexpr
volatile
restrict
type

Note

It must containtype.

Items to the left oftype will be placed to the left of the type andaligned in the order supplied. Items to the right oftype will beplaced to the right of the type and aligned in the order supplied.

QualifierOrder:[inline,static,type,const,volatile]

RawStringFormats (ListofRawStringFormats)clang-format 6¶

Defines hints for detecting supported languages code blocks in rawstrings.

A raw string with a matching delimiter or a matching enclosing functionname will be reformatted assuming the specified language based on thestyle for that language defined in the .clang-format file. If no style hasbeen defined in the .clang-format file for the specific language, apredefined style given byBasedOnStyle is used. IfBasedOnStyle isnot found, the formatting is based onLLVM style. A matching delimitertakes precedence over a matching enclosing function name for determiningthe language of the raw string contents.

If a canonical delimiter is specified, occurrences of other delimiters forthe same language will be updated to the canonical if possible.

There should be at most one specification per language and each delimiterand enclosing function should not occur in multiple specifications.

To configure this in the .clang-format file, use:

RawStringFormats:-Language:TextProtoDelimiters:-pb-protoEnclosingFunctions:-PARSE_TEXT_PROTOBasedOnStyle:google-Language:CppDelimiters:-cc-cppBasedOnStyle:LLVMCanonicalDelimiter:cc

ReferenceAlignment (ReferenceAlignmentStyle)clang-format 13¶

Reference alignment style (overridesPointerAlignment for references).

Possible values:

RAS_Pointer (in configuration:Pointer)Align reference likePointerAlignment.
RAS_Left (in configuration:Left)Align reference to the left.
```
int&a;
```
RAS_Right (in configuration:Right)Align reference to the right.
```
int&a;
```
RAS_Middle (in configuration:Middle)Align reference in the middle.
```
int&a;
```

ReflowComments (ReflowCommentsStyle)clang-format 3.8¶

Comment reformatting style.

Possible values:

RCS_Never (in configuration:Never)Leave comments untouched.

// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information/* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information *//* third veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information     * and a misaligned second line */

RCS_IndentOnly (in configuration:IndentOnly)Only apply indentation rules, moving comments left or right, withoutchanging formatting inside the comments.

// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information/* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information *//* third veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information * and a misaligned second line */

RCS_Always (in configuration:Always)Apply indentation rules and reflow long comments into new lines, tryingto obey theColumnLimit.

// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of// information/* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of * information *//* third veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of * information and a misaligned second line */

RemoveBracesLLVM (Boolean)clang-format 14¶

Remove optional braces of control statements (if,else,for,andwhile) in C++ according to the LLVM coding style.

Warning

This option will be renamed and expanded to support other styles.

Warning

false:true:if(isa<FunctionDecl>(D)){vs.if(isa<FunctionDecl>(D))handleFunctionDecl(D);handleFunctionDecl(D);}elseif(isa<VarDecl>(D)){elseif(isa<VarDecl>(D))handleVarDecl(D);handleVarDecl(D);}if(isa<VarDecl>(D)){vs.if(isa<VarDecl>(D)){for(auto*A:D.attrs()){for(auto*A:D.attrs())if(shouldProcessAttr(A)){if(shouldProcessAttr(A))handleAttr(A);handleAttr(A);}}}}if(isa<FunctionDecl>(D)){vs.if(isa<FunctionDecl>(D))for(auto*A:D.attrs()){for(auto*A:D.attrs())handleAttr(A);handleAttr(A);}}if(auto*D=(T)(D)){vs.if(auto*D=(T)(D)){if(shouldProcess(D)){if(shouldProcess(D))handleVarDecl(D);handleVarDecl(D);}else{elsemarkAsIgnored(D);markAsIgnored(D);}}}if(a){vs.if(a)b();b();}else{elseif(c)if(c){d();d();else}else{e();e();}}

RemoveEmptyLinesInUnwrappedLines (Boolean)clang-format 20¶

Remove empty lines within unwrapped lines.

false:true:intcvs.intc=a+b;=a+b;enum:unsignedvs.enum:unsigned{AA=0,{BBAA=0,}myEnum;BB}myEnum;while(vs.while(true){}true){}

RemoveParentheses (RemoveParenthesesStyle)clang-format 17¶

Remove redundant parentheses.

Warning

Possible values:

RPS_Leave (in configuration:Leave)Do not remove parentheses.

class__declspec((dllimport))X{};co_return(((0)));return((a+b)-((c+d)));

RPS_MultipleParentheses (in configuration:MultipleParentheses)Replace multiple parentheses with single parentheses.
```
class__declspec(dllimport)X{};co_return(0);return((a+b)-(c+d));
```
RPS_ReturnStatement (in configuration:ReturnStatement)Also remove parentheses enclosing the expression in areturn/co_return statement.
```
class__declspec(dllimport)X{};co_return0;return(a+b)-(c+d);
```

RemoveSemicolon (Boolean)clang-format 16¶

Remove semicolons after the closing braces of functions andconstructors/destructors.

Warning

false:true:intmax(inta,intb){intmax(inta,intb){returna>b?a:b;returna>b?a:b;};}

RequiresClausePosition (RequiresClausePositionStyle)clang-format 15¶

The position of therequires clause.

Possible values:

RCPS_OwnLine (in configuration:OwnLine)Always put therequires clause on its own line (possibly followed bya semicolon).

template<typenameT>requiresC<T>structFoo{...template<typenameT>voidbar(Tt)requiresC<T>;template<typenameT>requiresC<T>voidbar(Tt){...template<typenameT>voidbaz(Tt)requiresC<T>{...

RCPS_OwnLineWithBrace (in configuration:OwnLineWithBrace)As withOwnLine, except, unless otherwise prohibited, place afollowing open brace (of a function definition) to follow on the sameline.
```
voidbar(Tt)requiresC<T>{return;}voidbar(Tt)requiresC<T>{}template<typenameT>requiresC<T>voidbaz(Tt){...
```
RCPS_WithPreceding (in configuration:WithPreceding)Try to put the clause together with the preceding part of a declaration.For class templates: stick to the template declaration.For function templates: stick to the template declaration.For function declaration followed by a requires clause: stick to theparameter list.
```
template<typenameT>requiresC<T>structFoo{...template<typenameT>requiresC<T>voidbar(Tt){...template<typenameT>voidbaz(Tt)requiresC<T>{...
```

RCPS_WithFollowing (in configuration:WithFollowing)Try to put therequires clause together with the class or functiondeclaration.

template<typenameT>requiresC<T>structFoo{...template<typenameT>requiresC<T>voidbar(Tt){...template<typenameT>voidbaz(Tt)requiresC<T>{...

RCPS_SingleLine (in configuration:SingleLine)Try to put everything in the same line if possible. Otherwise normalline breaking rules take over.

// Fitting:template<typenameT>requiresC<T>structFoo{...template<typenameT>requiresC<T>voidbar(Tt){...template<typenameT>voidbar(Tt)requiresC<T>{...// Not fitting, one possible example:template<typenameLongName>requiresC<LongName>structFoo{...template<typenameLongName>requiresC<LongName>voidbar(LongNameln){template<typenameLongName>voidbar(LongNameln)requiresC<LongName>{

RequiresExpressionIndentation (RequiresExpressionIndentationKind)clang-format 16¶

The indentation used for requires expression bodies.

Possible values:

REI_OuterScope (in configuration:OuterScope)Align requires expression body relative to the indentation level of theouter scope the requires expression resides in.This is the default.
```
template<typenameT>conceptC=requires(Tt){...}
```
REI_Keyword (in configuration:Keyword)Align requires expression body relative to therequires keyword.
```
template<typenameT>conceptC=requires(Tt){...}
```

SeparateDefinitionBlocks (SeparateDefinitionStyle)clang-format 14¶

Specifies the use of empty lines to separate definition blocks, includingclasses, structs, enums, and functions.

Neverv.s.Always#include<cstring>              #include <cstring>structFoo{inta,b,c;structFoo{};inta,b,c;namespaceNs{};classBar{public:namespaceNs{structFoobar{classBar{inta;public:intb;structFoobar{};inta;private:intb;intt;};intmethod1(){// ...                      private:}intt;enumList{ITEM1,intmethod1(){ITEM2// ...};}template<typenameT>intmethod2(Tx){enumList{// ...                          ITEM1,}ITEM2inti,j,k;};intmethod3(intpar){// ...                        template<typename T>}intmethod2(Tx){};// ...classC{};}}inti,j,k;intmethod3(intpar){// ...}};classC{};}

Possible values:

SDS_Leave (in configuration:Leave)Leave definition blocks as they are.
SDS_Always (in configuration:Always)Insert an empty line between definition blocks.
SDS_Never (in configuration:Never)Remove any empty line between definition blocks.

ShortNamespaceLines (Unsigned)clang-format 13¶

The maximal number of unwrapped lines that a short namespace spans.Defaults to 1.

This determines the maximum length of short namespaces by countingunwrapped lines (i.e. containing neither opening nor closingnamespace brace) and makesFixNamespaceComments omit addingend comments for those.

ShortNamespaceLines:1vs.ShortNamespaceLines:0namespacea{namespacea{intfoo;intfoo;}}// namespace aShortNamespaceLines:1vs.ShortNamespaceLines:0namespaceb{namespaceb{intfoo;intfoo;intbar;intbar;}// namespace b                   } // namespace b

SkipMacroDefinitionBody (Boolean)clang-format 18¶: Do not format macro definition body.

SortIncludes (SortIncludesOptions)clang-format 3.8¶

Controls if and how clang-format will sort#includes.

Nested configuration flags:

Includes sorting options.

boolEnabled Iftrue, includes are sorted based on the other suboptions below.(Never is deprecated byEnabled:false.)

boolIgnoreCase Whether or not includes are sorted in a case-insensitive fashion.(CaseSensitive andCaseInsensitive are deprecated byIgnoreCase:false andIgnoreCase:true, respectively.)

true:false:#include"A/B.h"    vs.    #include "A/B.h"#include"A/b.h"           #include "A/b.h"#include"a/b.h"           #include "B/A.h"#include"B/A.h"           #include "B/a.h"#include"B/a.h"           #include "a/b.h"

boolIgnoreExtension When sorting includes in each block, only take file extensions intoaccount if two includes compare equal otherwise.

true:false:#include"A.h"         vs.    # include "A-util.h"#include"A.inc"              # include "A.h"#include"A-util.h"           # include "A.inc"

SortJavaStaticImport (SortJavaStaticImportOptions)clang-format 12¶

When sorting Java imports, by default static imports are placed beforenon-static imports. IfJavaStaticImportAfterImport isAfter,static imports are placed after non-static imports.

Possible values:

SJSIO_Before (in configuration:Before)Static imports are placed before non-static imports.
```
import staticorg.example.function1;importorg.example.ClassA;
```
SJSIO_After (in configuration:After)Static imports are placed after non-static imports.
```
importorg.example.ClassA;import staticorg.example.function1;
```

SortUsingDeclarations (SortUsingDeclarationsOptions)clang-format 5¶

Controls if and how clang-format will sort using declarations.

Possible values:

SUD_Never (in configuration:Never)Using declarations are never sorted.

usingstd::chrono::duration_cast;usingstd::move;usingboost::regex;usingboost::regex_constants::icase;usingstd::string;

SUD_Lexicographic (in configuration:Lexicographic)Using declarations are sorted in the order defined as follows:Split the strings by:: and discard any initial empty strings. Sortthe lists of names lexicographically, and within those groups, names arein case-insensitive lexicographic order.
```
usingboost::regex;usingboost::regex_constants::icase;usingstd::chrono::duration_cast;usingstd::move;usingstd::string;
```
SUD_LexicographicNumeric (in configuration:LexicographicNumeric)Using declarations are sorted in the order defined as follows:Split the strings by:: and discard any initial empty strings. Thelast element of each list is a non-namespace name; all others arenamespace names. Sort the lists of names lexicographically, where thesort order of individual names is that all non-namespace names comebefore all namespace names, and within those groups, names are incase-insensitive lexicographic order.
```
usingboost::regex;usingboost::regex_constants::icase;usingstd::move;usingstd::string;usingstd::chrono::duration_cast;
```

SpaceAfterCStyleCast (Boolean)clang-format 3.5¶

Iftrue, a space is inserted after C style casts.

true:false:(int)i;vs.(int)i;

SpaceAfterLogicalNot (Boolean)clang-format 9¶

Iftrue, a space is inserted after the logical not operator (!).

true:false:!someExpression();vs.!someExpression();

SpaceAfterOperatorKeyword (Boolean)clang-format 21¶

Iftrue, a space will be inserted after theoperator keyword.

true:false:booloperator==(inta);vs.booloperator==(inta);

SpaceAfterTemplateKeyword (Boolean)clang-format 4¶

Iftrue, a space will be inserted after thetemplate keyword.

true:false:template<int>voidfoo();vs.template<int>voidfoo();

SpaceAroundPointerQualifiers (SpaceAroundPointerQualifiersStyle)clang-format 12¶

Defines in which cases to put a space before or after pointer qualifiers

Possible values:

SAPQ_Default (in configuration:Default)Don’t ensure spaces around pointer qualifiers and use PointerAlignmentinstead.
```
PointerAlignment:LeftPointerAlignment:Rightvoid*const*x=NULL;vs.void*const*x=NULL;
```
SAPQ_Before (in configuration:Before)Ensure that there is a space before pointer qualifiers.
```
PointerAlignment:LeftPointerAlignment:Rightvoid*const*x=NULL;vs.void*const*x=NULL;
```
SAPQ_After (in configuration:After)Ensure that there is a space after pointer qualifiers.
```
PointerAlignment:LeftPointerAlignment:Rightvoid*const*x=NULL;vs.void*const*x=NULL;
```
SAPQ_Both (in configuration:Both)Ensure that there is a space both before and after pointer qualifiers.
```
PointerAlignment:LeftPointerAlignment:Rightvoid*const*x=NULL;vs.void*const*x=NULL;
```

SpaceBeforeAssignmentOperators (Boolean)clang-format 3.7¶

Iffalse, spaces will be removed before assignment operators.

true:false:inta=5;vs.inta=5;a+=42;a+=42;

SpaceBeforeCaseColon (Boolean)clang-format 12¶

Iffalse, spaces will be removed before case colon.

true:falseswitch(x){vs.switch(x){case1:break;case1:break;}}

SpaceBeforeCpp11BracedList (Boolean)clang-format 7¶

Iftrue, a space will be inserted before a C++11 braced listused to initialize an object (after the preceding identifier or type).

true:false:Foofoo{bar};vs.Foofoo{bar};Foo{};Foo{};vector<int>{1,2,3};vector<int>{1,2,3};newint[3]{1,2,3};newint[3]{1,2,3};

SpaceBeforeCtorInitializerColon (Boolean)clang-format 7¶

Iffalse, spaces will be removed before constructor initializercolon.

true:false:Foo::Foo():a(a){}Foo::Foo():a(a){}

SpaceBeforeInheritanceColon (Boolean)clang-format 7¶

Iffalse, spaces will be removed before inheritance colon.

true:false:classFoo:Bar{}vs.classFoo:Bar{}

SpaceBeforeJsonColon (Boolean)clang-format 17¶

Iftrue, a space will be added before a JSON colon. For otherlanguages, e.g. JavaScript, useSpacesInContainerLiterals instead.

true:false:{{"key":"value"vs."key":"value"}}

SpaceBeforeParens (SpaceBeforeParensStyle)clang-format 3.5¶

Defines in which cases to put a space before opening parentheses.

Possible values:

SBPO_Never (in configuration:Never)This isdeprecated and replaced byCustom below, with allSpaceBeforeParensOptions butAfterPlacementOperator set tofalse.
SBPO_ControlStatements (in configuration:ControlStatements)Put a space before opening parentheses only after control statementkeywords (for/if/while...).
```
voidf(){if(true){f();}}
```
SBPO_ControlStatementsExceptControlMacros (in configuration:ControlStatementsExceptControlMacros)Same asSBPO_ControlStatements except this option doesn’t apply toForEach and If macros. This is useful in projects where ForEach/Ifmacros are treated as function calls instead of control statements.SBPO_ControlStatementsExceptForEachMacros remains an alias forbackward compatibility.
```
voidf(){Q_FOREACH(...){f();}}
```
SBPO_NonEmptyParentheses (in configuration:NonEmptyParentheses)Put a space before opening parentheses only if the parentheses are notempty.
```
void(){if(true){f();g(x,y,z);}}
```
SBPO_Always (in configuration:Always)Always put a space before opening parentheses, except when it’sprohibited by the syntax rules (in function-like macro definitions) orwhen determined by other style rules (after unary operators, openingparentheses, etc.)
```
voidf(){if(true){f();}}
```
SBPO_Custom (in configuration:Custom)Configure each individual space before parentheses inSpaceBeforeParensOptions.

SpaceBeforeParensOptions (SpaceBeforeParensCustom)clang-format 14¶

Control of individual space before parentheses.

IfSpaceBeforeParens is set toCustom, use this to specifyhow each individual space before parentheses case should be handled.Otherwise, this is ignored.

# Example of usage:SpaceBeforeParens:CustomSpaceBeforeParensOptions:AfterControlStatements:trueAfterFunctionDefinitionName:true

Nested configuration flags:

Precise control over the spacing before parentheses.

# Should be declared this way:SpaceBeforeParens:CustomSpaceBeforeParensOptions:AfterControlStatements:trueAfterFunctionDefinitionName:true

boolAfterControlStatements Iftrue, put space between control statement keywords(for/if/while…) and opening parentheses.
```
true:false:if(...){}vs.if(...){}
```
boolAfterForeachMacros Iftrue, put space between foreach macros and opening parentheses.
```
true:false:FOREACH(...)vs.FOREACH(...)<loop-body><loop-body>
```
boolAfterFunctionDeclarationName Iftrue, put a space between function declaration name and openingparentheses.
```
true:false:voidf();vs.voidf();
```
boolAfterFunctionDefinitionName Iftrue, put a space between function definition name and openingparentheses.
```
true:false:voidf(){}vs.voidf(){}
```
boolAfterIfMacros Iftrue, put space between if macros and opening parentheses.
```
true:false:IF(...)vs.IF(...)<conditional-body><conditional-body>
```

boolAfterOverloadedOperator Iftrue, put a space between operator overloading and openingparentheses.

true:false:voidoperator++(inta);vs.voidoperator++(inta);object.operator++(10);object.operator++(10);

boolAfterPlacementOperator Iftrue, put a space between operatornew/delete and openingparenthesis.
```
true:false:new(buf)T;vs.new(buf)T;delete(buf)T;delete(buf)T;
```
boolAfterRequiresInClause Iftrue, put space between requires keyword in a requires clause andopening parentheses, if there is one.
```
true:false:template<typenameT>vs.template<typenameT>requires(A<T>&&B<T>)requires(A<T>&&B<T>)......
```
boolAfterRequiresInExpression Iftrue, put space between requires keyword in a requires expressionand opening parentheses.
```
true:false:template<typenameT>vs.template<typenameT>conceptC=requires(Tt){conceptC=requires(Tt){......}}
```
boolBeforeNonEmptyParentheses Iftrue, put a space before opening parentheses only if theparentheses are not empty.
```
true:false:voidf(inta);vs.voidf();f(a);f();
```

SpaceBeforeRangeBasedForLoopColon (Boolean)clang-format 7¶

Iffalse, spaces will be removed before range-based for loopcolon.

true:false:for(autov:values){}vs.for(autov:values){}

SpaceBeforeSquareBrackets (Boolean)clang-format 10¶

Iftrue, spaces will be before[.Lambdas will not be affected. Only the first[ will get a space added.

true:false:inta[5];vs.inta[5];inta[5][5];vs.inta[5][5];

SpaceInEmptyBlock (Boolean)clang-format 10¶

Iftrue, spaces will be inserted into{}.

true:false:voidf(){}vs.voidf(){}while(true){}while(true){}

SpaceInEmptyParentheses (Boolean)clang-format 3.7¶: Iftrue, spaces may be inserted into().This option isdeprecated. SeeInEmptyParentheses ofSpacesInParensOptions.

SpacesBeforeTrailingComments (Unsigned)clang-format 3.7¶

The number of spaces before trailing line comments(// - comments).

This does not affect trailing block comments (/* - comments) as thosecommonly have different usage patterns and a number of special cases. Inthe case of Verilog, it doesn’t affect a comment right after the openingparenthesis in the port or parameter list in a module header, because itis probably for the port on the following line instead of the parenthesisit follows.

SpacesBeforeTrailingComments:3voidf(){if(true){// foo1f();// bar}// foo}

SpacesInAngles (SpacesInAnglesStyle)clang-format 3.4¶

The SpacesInAnglesStyle to use for template argument lists.

Possible values:

SIAS_Never (in configuration:Never)Remove spaces after< and before>.
```
static_cast<int>(arg);std::function<void(int)>fct;
```
SIAS_Always (in configuration:Always)Add spaces after< and before>.
```
static_cast<int>(arg);std::function<void(int)>fct;
```
SIAS_Leave (in configuration:Leave)Keep a single space after< and before> if any spaces werepresent. OptionStandard:Cpp03 takes precedence.

SpacesInCStyleCastParentheses (Boolean)clang-format 3.7¶: Iftrue, spaces may be inserted into C style casts.This option isdeprecated. SeeInCStyleCasts ofSpacesInParensOptions.

SpacesInConditionalStatement (Boolean)clang-format 10¶: Iftrue, spaces will be inserted around if/for/switch/whileconditions.This option isdeprecated. SeeInConditionalStatements ofSpacesInParensOptions.

SpacesInContainerLiterals (Boolean)clang-format 3.7¶

Iftrue, spaces are inserted inside container literals (e.g. ObjC andJavascript array and dict literals). For JSON, useSpaceBeforeJsonColon instead.

true:false:vararr=[1,2,3];vs.vararr=[1,2,3];f({a:1,b:2,c:3});f({a:1,b:2,c:3});

SpacesInLineCommentPrefix (SpacesInLineComment)clang-format 13¶

How many spaces are allowed at the start of a line comment. To disable themaximum set it to-1, apart from that the maximum takes precedenceover the minimum.

Minimum=1Maximum=-1// One space is forced//  but more spaces are possibleMinimum=0Maximum=0//Forces to start every comment directly after the slashes

Note that in line comment sections the relative indent of the subsequentlines is kept, that means the following:

before:after:Minimum:1//if (b) {                                // if (b) {//  return true;                          //   return true;//}                                       // }Maximum:0/// List:                                 ///List:///  - Foo                                /// - Foo///    - Bar                              ///   - Bar

This option has only effect ifReflowComments is set totrue.

Nested configuration flags:

Control of spaces within a single line comment.

unsignedMinimum The minimum number of spaces at the start of the comment.
unsignedMaximum The maximum number of spaces at the start of the comment.

SpacesInParens (SpacesInParensStyle)clang-format 17¶

Defines in which cases spaces will be inserted after( and before).

Possible values:

SIPO_Never (in configuration:Never)Never put a space in parentheses.
```
voidf(){if(true){f();}}
```
SIPO_Custom (in configuration:Custom)Configure each individual space in parentheses inSpacesInParensOptions.

SpacesInParensOptions (SpacesInParensCustom)clang-format 17¶

Control of individual spaces in parentheses.

IfSpacesInParens is set toCustom, use this to specifyhow each individual space in parentheses case should be handled.Otherwise, this is ignored.

# Example of usage:SpacesInParens:CustomSpacesInParensOptions:ExceptDoubleParentheses:falseInConditionalStatements:trueInEmptyParentheses:true

Nested configuration flags:

Precise control over the spacing in parentheses.

# Should be declared this way:SpacesInParens:CustomSpacesInParensOptions:ExceptDoubleParentheses:falseInConditionalStatements:trueOther:true

boolExceptDoubleParentheses Override any of the following options to prevent addition of spacewhen both opening and closing parentheses use multiple parentheses.
```
true:__attribute__((noreturn))__decltype__((x))if((a=b))false:Usestheapplicableoption.
```
boolInConditionalStatements Put a space in parentheses only inside conditional statements(for/if/while/switch...).
```
true:false:if(a){...}vs.if(a){...}while(i<5){...}while(i<5){...}
```

boolInCStyleCasts Put a space in C style casts.

true:false:x=(int32)yvs.x=(int32)yy=((int(*)(int))foo)(x);y=((int(*)(int))foo)(x);

boolInEmptyParentheses Insert a space in empty parentheses, i.e.().

true:false:voidf(){vs.voidf(){intx[]={foo(),bar()};intx[]={foo(),bar()};if(true){if(true){f();f();}}}}

boolOther Put a space in parentheses not covered by preceding options.
```
true:false:tf(Deleted&)&=delete;vs.tf(Deleted&)&=delete;
```

SpacesInParentheses (Boolean)clang-format 3.7¶: Iftrue, spaces will be inserted after( and before).This option isdeprecated. The previous behavior is preserved by usingSpacesInParens withCustom and by setting allSpacesInParensOptions totrue except forInCStyleCasts andInEmptyParentheses.

SpacesInSquareBrackets (Boolean)clang-format 3.7¶

Iftrue, spaces will be inserted after[ and before].Lambdas without arguments or unspecified size array declarations will notbe affected.

true:false:inta[5];vs.inta[5];std::unique_ptr<int[]>foo(){}// Won't be affected

Standard (LanguageStandard)clang-format 3.7¶

Parse and format C++ constructs compatible with this standard.

c++03:latest:vector<set<int>>x;vs.vector<set<int>>x;

Possible values:

LS_Cpp03 (in configuration:c++03)Parse and format as C++03.Cpp03 is a deprecated alias forc++03
LS_Cpp11 (in configuration:c++11)Parse and format as C++11.
LS_Cpp14 (in configuration:c++14)Parse and format as C++14.
LS_Cpp17 (in configuration:c++17)Parse and format as C++17.
LS_Cpp20 (in configuration:c++20)Parse and format as C++20.
LS_Latest (in configuration:Latest)Parse and format using the latest supported language version.Cpp11 is a deprecated alias forLatest
LS_Auto (in configuration:Auto)Automatic detection based on the input.

StatementAttributeLikeMacros (ListofStrings)clang-format 12¶

Macros which are ignored in front of a statement, as if they were anattribute. So that they are not parsed as identifier, for example for Qtsemit.

AlignConsecutiveDeclarations:trueStatementAttributeLikeMacros:[]unsignedchardata='x';emitsignal(data);// This is parsed as variable declaration.AlignConsecutiveDeclarations:trueStatementAttributeLikeMacros:[emit]unsignedchardata='x';emitsignal(data);// Now it's fine again.

StatementMacros (ListofStrings)clang-format 8¶

A vector of macros that should be interpreted as complete statements.

Typical macros are expressions and require a semicolon to be added.Sometimes this is not the case, and this allows to make clang-format awareof such cases.

For example: Q_UNUSED

TabWidth (Unsigned)clang-format 3.7¶: The number of columns used for tab stops.

TableGenBreakInsideDAGArg (DAGArgStyle)clang-format 19¶

The styles of the line break inside the DAGArg in TableGen.

Possible values:

DAS_DontBreak (in configuration:DontBreak)Never break inside DAGArg.
```
letDAGArgIns=(insi32:$src1,i32:$src2);
```
DAS_BreakElements (in configuration:BreakElements)Break inside DAGArg after each list element but for the last.This aligns to the first element.
```
letDAGArgIns=(insi32:$src1,i32:$src2);
```
DAS_BreakAll (in configuration:BreakAll)Break inside DAGArg after the operator and the all elements.
```
letDAGArgIns=(insi32:$src1,i32:$src2);
```

TableGenBreakingDAGArgOperators (ListofStrings)clang-format 19¶

Works only when TableGenBreakInsideDAGArg is not DontBreak.The string list needs to consist of identifiers in TableGen.If any identifier is specified, this limits the line breaks byTableGenBreakInsideDAGArg option only on DAGArg values beginning withthe specified identifiers.

For example the configuration,

TableGenBreakInsideDAGArg:BreakAllTableGenBreakingDAGArgOperators:[ins,outs]

makes the line break only occurs inside DAGArgs beginning with thespecified identifiersins andouts.

letDAGArgIns=(insi32:$src1,i32:$src2);letDAGArgOtherID=(otheri32:$other1,i32:$other2);letDAGArgBang=(!cast<SomeType>("Some")i32:$src1,i32:$src2)

TemplateNames (ListofStrings)clang-format 20¶

A vector of non-keyword identifiers that should be interpreted as templatenames.

A< after a template name is annotated as a template opener instead ofa binary operator.

TypeNames (ListofStrings)clang-format 17¶

A vector of non-keyword identifiers that should be interpreted as typenames.

A*,&, or&& between a type name and another non-keywordidentifier is annotated as a pointer or reference token instead of abinary operator.

TypenameMacros (ListofStrings)clang-format 9¶

A vector of macros that should be interpreted as type declarations insteadof as function calls.

These are expected to be macros of the form:

STACK_OF(...)

In the .clang-format configuration file, this can be configured like:

TypenameMacros:[STACK_OF,LIST]

For example: OpenSSL STACK_OF, BSD LIST_ENTRY.

UseCRLF (Boolean)clang-format 10¶: This option isdeprecated. SeeLF andCRLF ofLineEnding.

UseTab (UseTabStyle)clang-format 3.7¶

The way to use tab characters in the resulting file.

Possible values:

UT_Never (in configuration:Never)Never use tab.
UT_ForIndentation (in configuration:ForIndentation)Use tabs only for indentation.
UT_ForContinuationAndIndentation (in configuration:ForContinuationAndIndentation)Fill all leading whitespace with tabs, and use spaces for alignment thatappears within a line (e.g. consecutive assignments and declarations).
UT_AlignWithSpaces (in configuration:AlignWithSpaces)Use tabs for line continuation and indentation, and spaces foralignment.
UT_Always (in configuration:Always)Use tabs whenever we need to fill whitespace that spans at least fromone tab stop to the next one.

VariableTemplates (ListofStrings)clang-format 20¶

A vector of non-keyword identifiers that should be interpreted as variabletemplate names.

A) after a variable template instantiation isnot annotated asthe closing parenthesis of C-style cast operator.

VerilogBreakBetweenInstancePorts (Boolean)clang-format 17¶

For Verilog, put each port on its own line in module instantiations.

true:ffnandff1(.q(),.qbar(out1),.clear(in1),.preset(in2));false:ffnandff1(.q(),.qbar(out1),.clear(in1),.preset(in2));

WhitespaceSensitiveMacros (ListofStrings)clang-format 11¶

A vector of macros which are whitespace-sensitive and should notbe touched.

These are expected to be macros of the form:

STRINGIZE(...)

In the .clang-format configuration file, this can be configured like:

WhitespaceSensitiveMacros:[STRINGIZE,PP_STRINGIZE]

For example: BOOST_PP_STRINGIZE

WrapNamespaceBodyWithEmptyLines (WrapNamespaceBodyWithEmptyLinesStyle)clang-format 20¶

Wrap namespace body with empty lines.

Possible values:

WNBWELS_Never (in configuration:Never)Remove all empty lines at the beginning and the end of namespace body.
```
namespaceN1{namespaceN2{function();}}
```
WNBWELS_Always (in configuration:Always)Always have at least one empty line at the beginning and the end ofnamespace body except that the number of empty lines between consecutivenested namespace definitions is not increased.
```
namespaceN1{namespaceN2{function();}}
```
WNBWELS_Leave (in configuration:Leave)Keep existing newlines at the beginning and the end of namespace body.MaxEmptyLinesToKeep still applies.

Adding additional style options¶

Each additional style option adds costs to the clang-format project. Some ofthese costs affect the clang-format development itself, as we need to makesure that any given combination of options work and that new features don’tbreak any of the existing options in any way. There are also costs for end usersas options become less discoverable and people have to think about and make adecision on options they don’t really care about.

The goal of the clang-format project is more on the side of supporting alimited set of styles really well as opposed to supporting every single styleused by a codebase somewhere in the wild. Of course, we do want to support allmajor projects and thus have established the following bar for adding styleoptions. Each new style option must:

be used in a project of significant size (have dozens of contributors)
have a publicly accessible style guide
have a person willing to contribute and maintain patches

Examples¶

A style similar to theLinux Kernel style:

BasedOnStyle:LLVMIndentWidth:8UseTab:AlwaysBreakBeforeBraces:LinuxAllowShortIfStatementsOnASingleLine:falseIndentCaseLabels:false

The result is (imagine that tabs are used for indentation here):

voidtest(){switch(x){case0:case1:do_something();break;case2:do_something_else();break;default:break;}if(condition)do_something_completely_different();if(x==y){q();}elseif(x>y){w();}else{r();}}

A style similar to the default Visual Studio formatting style:

UseTab:NeverIndentWidth:4BreakBeforeBraces:AllmanAllowShortIfStatementsOnASingleLine:falseIndentCaseLabels:falseColumnLimit:0

The result is:

voidtest(){switch(suffix){case0:case1:do_something();break;case2:do_something_else();break;default:break;}if(condition)do_something_completely_different();if(x==y){q();}elseif(x>y){w();}else{r();}}

Movatterモバイル変換

Clang 22.0.0git documentation