Clang-Formatの書式について

clang-formatを用いてコードを整形する際のコマンドライン引数又は定義ファイル(.clang-format)の書式についての説明になります。

なお、本稿は以下の公式ドキュメントの記述に、解説を付与した内容となります。
(全文の直訳ではありません。噛み砕いて解釈を追加したものとなります。)

https://clang.llvm.org/docs/ClangFormatStyleOptions.html

## 前提条件
本稿を記載の為、以下の環境での確認をおこなっています。
・RHEL9.0、clang-format 15.0
・Windows10Pro 21H2、VSCode1.69.2、clang-format 8.0.1


## １. 指定方法及び基本的な書式について
大きく2通りの指定方法がある。

その１．コマンドライン引数としてパラメータを指定する
```bash:書式例
clang-format --style="{ BasedOnStyle: LLVM, IndentWidth: 4 }" input_file_name.cpp
```

その２．コマンドライン引数として設定ファイルを指定する
```bash:書式例
clang-format --style=file:"~/project_dir/.clang-format" input_file_name.cpp
```

clang-formatのコマンドオプションの詳細は以下を参照。

https://clang.llvm.org/docs/ClangFormat.html

また、VSCodeで使用の際は設定ファイルより値を指定する方法となる。
設定ファイルは、「.clang-format」の名称で作成する。
作成したファイルは、ソースコード直下又はC_Cpp:Clang_format_pathにて指定したパスから読み込みを行う。
C_Cpp:Clang_format_pathの設定方法は次を参照。
![無題.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1317688/56c3047a-7af3-ff93-ca48-fcde5bcca56a.png)

設定ファイルはYAML形式で記載を行う。
```yaml:例
キー1: 値1
キー2: 値2
# コメント
...
```
また、言語を指定して定義を切り分けることもできる。
```yaml:書式例
---
# Language指定なし(共通定義)。
# 既定値としてLLVMを使用、インデントをスペース4つに指定する。
BasedOnStyle: LLVM
IndentWidth: 4
---
♯ C++用の定義
Language: Cpp
DerivePointerAlignment: false
PointerAlignment: Left
---
♯ JavaScript用の定義
Language: JavaScript
ColumnLimit: 100
---
♯ Protocol Buffers用の定義
Language: Proto
DisableFormat: true
---
♯ C#用の定義
Language: CSharp
ColumnLimit: 100
...
```

:::note info
以下のコマンドを実行すると、clang-formatの既定値の定義を出力することができる。
(ベースファイルとして使える)
:::

```bash:
clang-format -style=llvm -dump-config > .clang-format
```
※styleに指定できる値は、BasedOnStyleを参照

## ２. 書式及びオプション
style及び.clang-formatファイルに指定可能な個々のフォーマットスタイルについて記載する。

【凡例】
<dl><dt>
キー名(値の型) <font color=green>使用可能なバージョン</font>
</dt><dd>
　概要<br/>
　値の範囲<br/>
　書式例<br/>
</dd></dl>

の順で記載する。
値の型は、
| 型             | 意味 | 例 | 備考 |
|:---------------|:----|:----|:----|
|Integer         | 数値     | 100,-20 |  |
|Unsigned        | 正の数値 | 50 | 負数を指定するとエラーとなる |
|String          | 文字列   | "(_test)?$" | 主に正規表現を指定する項目で使用 |
|List of Strings | 文字列の配列 | ['com.example', 'com', 'org'] | 主にキーワードのリストを指定する項目で使用 |
|Boolean         | 真偽値 | true, false | |

その他、個別の列挙型がある。
列挙型の一覧については、以下のドキュメントを参照

https://clang.llvm.org/doxygen/structclang_1_1format_1_1FormatStyle.html

:::note warn
**注意**
一部のキーについてデータ型がclang-formatのバージョンによって、Booleanから列挙型に変更となっているものがあります。
旧のデータ型がBooleanの場合、レガシーオプションとして列挙型＋Booleanのどちらでも指定可能となっています。
本稿を執筆するにあたり、各キーがどのバージョンでBooleanから列挙型に変更となったかまでの調査は出来ておりません。
ただし、レガシーオプションが存在するキーについてはその内容も記述をおこなっています。
ご自身が使用する環境で列挙型での指定がエラーとなる場合、Booleanでの指定を試してください。
:::

<!-- ***************  BasedOnStyle START  *************** -->
<dl><dt>
BasedOnStyle(String)
</dt><dd>
すべてのオプションの既定値となる値を指定する。<br/>

| 値 | 意味 |
|:--------------------|:------------|
| LLVM                | [LLVMコーディング規約](https://llvm.org/docs/CodingStandards.html)を標準とする |
| Google              | [Google C++ スタイルガイド](https://google.github.io/styleguide/cppguide.html)を標準とする|
| Chromium            | [Chromium スタイルガイド](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/styleguide/styleguide.md)を標準とする|
| Mozilla             | [Mozilla コーディングスタイル](https://firefox-source-docs.mozilla.org/code-quality/coding-style/index.html)を標準とする|
| WebKit              | [WebKit コードスタイル ガイドライン](https://www.webkit.org/coding/coding-style.html)を標準とする|
| Microsoft           | [.NET コードスタイルのルールオプション](https://docs.microsoft.com/en-us/dotnet/fundamentals/code-analysis/code-style-rule-options?view=vs-2022)を標準とする|
| GNU                 | [GNU コーディング規約](https://www.gnu.org/prep/standards/standards.html)を標準とする|
| InheritParentConfig | 親の設定を読み込み使用する。親が見つからない場合、フォールバックとして動作する。|

</dd></dl>
<!-- ***************  BasedOnStyleEND  *************** -->


<!-- ***************  AccessModifierOffset START  *************** -->
<dl><dt>
AccessModifierOffset(Integer) <font color=green>3.3以降</font>
</dt><dd>
アクセス修飾子(public等)のインデントまたはアウトデントに対する補正を指定する。<br/>
つまり、IndentWidthで指定した値にAccessModifierOffsetで指定した値を足した値が、インデントとして設定されます。<br/>
合計した値は最低0以上である必要があり、0より小さい値となる場合、AccessModifierOffsetの値は破棄されます。
</dd></dl>
<!-- ***************  AccessModifierOffset END  *************** -->


<!-- ***************  AlignAfterOpenBracket START  *************** -->
<dl><dt>
AlignAfterOpenBracket(BracketAlignmentStyle) <font color=green>3.8以降</font>
</dt><dd>
開き括弧の後の引数の並べ方を指定する。<br/>
この指定は、丸括弧、波括弧及び角括弧に適用となる。

| 値             | 意味 |
|:---------------|:-----|
| Align          | 開き括弧にパラメータの先頭を合わせる。 |
| DontAlign      | 位置を合わせない。次行以降のインデントにはContinuationIndentWidthを使用する。 |
| AlwaysBreak    | パラメータが1行に収まらない場合、常に開き括弧の後で改行を行う。 |
| BlockIndent    | AlwaysBreakと同じ動作。ただし、閉じ括弧を改行する。 |

<dl><dd>

```C++:Align
someLongFunction(argument1,
                 argument2);
```
```C++:DontAlign
someLongFunction(argument1,
    argument2);
```
```C++:AlwaysBreak
someLongFunction(
    argument1, argument2);
```
```C++:BlockIndent
someLongFunction(
    argument1, argument2
);
```
</dd></dl>

:::note warn
**警告**
現在(clang-format15.0時点)、丸括弧のみに適用されます。
:::

</dd></dl>
<!-- ***************  AlignAfterOpenBracket END  *************** -->

<!-- ***************  AlignArrayOfStructures START  *************** -->
<dl><dt>
AlignArrayOfStructures(ArrayInitializerAlignmentStyle) <font color=green>13以降</font>
</dt><dd>
構造体配列の初期化子について、整列方向を指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Left           | 配列の初期化リストを左寄せに整列する。 |
| Right          | 配列の初期化リストを右寄せに整列する。 |
| None           | 配列の初期化リストを整列を行わない。  |

<dl><dd>

```C++:Left
// 配列の初期化リストを左寄せに整列する
struct test demo[] =
{
    {56, 23,    "hello"},
    {-1, 93463, "world"},
    {7,  5,     "!!"   }
};
```
```C++:Right
// 配列の初期化リストを右寄せに整列する
struct test demo[] =
{
    {56,    23, "hello"},
    {-1, 93463, "world"},
    { 7,     5,    "!!"}
};
```
</dd></dl>

</dd></dl>
<!-- ***************  AlignArrayOfStructures END  *************** -->

<!-- ***************  AlignConsecutiveAssignments START  *************** -->

<dl><dt>
AlignConsecutiveAssignments(AlignConsecutiveStyle) <font color=green>3.8以降</font>
</dt><dd>
連続した代入の揃え方を指定する。<br/>
指定した値により、次のパラメータの値を決定する。<br/>
　・Enabled<br/>
　・AcrossEmptyLines<br/>
　・AcrossComments<br/>
　・AlignCompound<br/>
　・PadOperators<br/>
パラメータの意味については後述する。
<br/>
※公式ドキュメントの記述に誤りがある。公式の例にある個別パラメータへの真偽値の設定は出来ない。

| 値 \ パラメータ | Enabled | AcrossEmptyLines | AcrossComments | AlignCompound | PadOperators |
|:------|:----|:----|:----|:----|:----|
| None                        | false | false | false | false | true  |
| Consecutive                 | true  | false | false | false | true  |
| AcrossEmptyLines            | true  | true  | false | false | true  |
| AcrossComments              | true  | false | true  | false | true  |
| AcrossEmptyLinesAndComments | true  | true  | true  | false | true  |
| true                        | true  | false | false | false | true  |
| false                       | false | false | false | false | true  |

※AlignCompoundがtrueとなる値は存在しない。
　値にtrueを指定した場合、Consecutiveと同じ動作となる。同様にfalseを指定した場合、Noneと同じ動作となる。

各パラメータの設定値により、次の動作を行う。

<dl><dd>

<!-- ***************  AlignConsecutiveAssignments:Enabled START  *************** -->
<dl><dt>
Enabled(Boolean)
</dt><dd>
アライメントを有効とするかを指定する。
<dl><dd>

```C++:true
// アライメントを有効にする
int a            = 1;
int somelongname = 2;
double c         = 3;
```
```C++:false
// アライメントを無効とする
int a = 1;
int somelongname = 2;
double c = 3;
```
</dd></dl>
</dd></dl>
<!-- ***************  AlignConsecutiveAssignments:Enabled END  *************** -->

<!-- ***************  AlignConsecutiveAssignments:AcrossEmptyLines START  *************** -->
<dl><dt>
AcrossEmptyLines(Boolean)
</dt><dd>
空白行を挟んだ要素を整列するかを指定する。
<dl><dd>

```C++:true
// 空白行を挟んだ要素も整列を行う
int a            = 1;
int somelongname = 2;

double c         = 3;
```
```C++:false
// 空白行を挟んだ要素は別で整列を行う
int a            = 1;
int somelongname = 2;

double c = 3;
```
</dd></dl>
</dd></dl>
<!-- ***************  AlignConsecutiveAssignments:AcrossEmptyLines END  *************** -->

<!-- ***************  AlignConsecutiveAssignments:AcrossComments START  *************** -->
<dl><dt>
AcrossComments(Boolean)
</dt><dd>
コメント行を挟んだ要素を整列するかを指定する。
<dl><dd>

```C++:true
// コメント行を挟んだ要素も整列を行う
int a            = 1;
int somelongname = 2;
/* コメント */
double c         = 3;
```
```C++:false
// コメント行を挟んだ要素は別で整列を行う
int a            = 1;
int somelongname = 2;
/* コメント */
double c = 3;
```
</dd></dl>
</dd></dl>
<!-- ***************  AlignConsecutiveAssignments:AcrossComments END  *************** -->

<!-- ***************  AlignConsecutiveAssignments:AlignCompound START  *************** -->
<dl><dt>
AlignCompound(Boolean)
</dt><dd>
複合した演算子についての整列方法を指定する。<br/>
このフラグはAlignConsecutiveAssignmentsに対してのみ有効となる。
<dl><dd>

```C++:true
// 演算子と複合の=について、演算子を加味した位置に調整を行う
a   &= 2;
bbb  = 2;
```
```C++:false
// 演算子と複合の=について、演算子を加味しない位置に調整を行う
a &= 2;
bbb = 2;
```
</dd></dl>
</dd></dl>
<!-- ***************  AlignConsecutiveAssignments:AlignCompound END  *************** -->

<!-- ***************  AlignConsecutiveAssignments:PadOperators START  *************** -->
<dl><dt>
PadOperators(Boolean)
</dt><dd>
長い演算子と短い演算子についての整列方法を指定する。<br/>
このフラグはAlignConsecutiveAssignmentsに対してのみ有効となる。
<dl><dd>

```C++:true
// 演算子と複合の=について、演算子を加味した位置に調整を行う
// 演算子の幅も加味して=の位置を調整する
a   >>= 2;
bbb   = 2;

a     = 2;
bbb >>= 2;
```
```C++:false
// =の位置を軸として調整を行う
a >>= 2;
bbb = 2;

a     = 2;
bbb >>= 2;
```
</dd></dl>
</dd></dl>
<!-- ***************  AlignConsecutiveAssignments:PadOperators END  *************** -->
</dd></dl>
</dd></dl>
<!-- ***************  AlignArrayOfStructures END  *************** -->

<!-- ***************  AlignConsecutiveBitFields START  *************** -->
<dl><dt>
AlignConsecutiveBitFields(AlignConsecutiveStyle) <font color=green>11以降</font>
</dt><dd>
連続したビットフィールドの揃え方を指定する。<br/>
指定可能な値の範囲はAlignConsecutiveAssignmentsと同じのため、そちらを参照のこと。
</dd></dl>
<!-- ***************  AlignConsecutiveBitFields END  *************** -->

<!-- ***************  AlignConsecutiveDeclarations START  *************** -->
<dl><dt>
AlignConsecutiveDeclarations(AlignConsecutiveStyle) <font color=green>3.8以降</font>
</dt><dd>
連続した宣言の揃え方を指定する。<br/>
指定可能な値の範囲はAlignConsecutiveAssignmentsと同じのため、そちらを参照のこと。
</dd></dl>
<!-- ***************  AlignConsecutiveDeclarations END  *************** -->

<!-- ***************  AlignConsecutiveMacros START  *************** -->
<dl><dt>
AlignConsecutiveMacros(AlignConsecutiveStyle) <font color=green>9以降</font>
</dt><dd>
連続したマクロ定義の揃え方を指定する。<br/>
指定可能な値の範囲はAlignConsecutiveAssignmentsと同じのため、そちらを参照のこと。
</dd></dl>
<!-- ***************  AlignConsecutiveMacros END  *************** -->

<!-- ***************  AlignEscapedNewlines START  *************** -->
<dl><dt>
AlignEscapedNewlines(EscapedNewlineAlignmentStyle) <font color=green>5以降</font>
</dt><dd>
エスケープ文字された改行文字の揃え方を指定する。<br/>

| 値        | 意味 |
|:----------|:----|
| DontAlign | エスケープされた改行文字を揃えない |
| Left      | エスケープされた改行文字をできるだけ左に揃える |
| Right     | エスケープされた改行文字を右端の列に揃える |

<dl><dd>

```C++:DontAlign
// エスケープされた改行文字を揃えない(各行左詰めにする)
#define A \
  int aaaa; \
  int b; \
  int dddddddddd;
```
```C++:Left
// エスケープされた改行文字をできるだけ左に揃える
#define A   \
  int aaaa; \
  int b;    \
  int dddddddddd;
```
```C++:Right
// ColumnLimitで指定した値の位置にエスケープ文字を合わせる。
// ColumnLimitが0(無制限)の場合、Leftと同じ動作となる。
#define A                                                                      \
  int aaaa;                                                                    \
  int b;                                                                       \
  int dddddddddd;
```
</dd></dl>

</dd></dl>
<!-- ***************  AlignEscapedNewlines END  *************** -->

<!-- ***************  AlignOperands START  *************** -->
<dl><dt>
AlignOperands(OperandAlignmentStyle) <font color=green>3.5以降</font>
</dt><dd>
2項式及び3項式のオペランドの位置を指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| DontAlign      | オペランドの整列を行わない。改行した行は行頭からContinuationIndentWidth分のスペースがインデントされる。 |
| Align          | 水平に揃える |
| AlignAfterOperator | 水平に揃える。Alignとの差はBreakBeforeBinaryOperatorsを指定した場合の動作だけとなる。 |
| true           | Alignと同じ動作。(レガシーオプション) |
| false          | DontAlignと同じ動作。(レガシーオプション) |

<dl><dd>


```C++:Align及びAlignAfterOperator(BreakBeforeBinaryOperatorsがNone又は未指定)
// オペランドは行末に付与され、改行後は変数名等を先頭に整列が行われる
int aaa = bbbbbbbbbbbbbbb +
          ccccccccccccccc;
```

```C++:Align(BreakBeforeBinaryOperatorsが指定あり)
// オペランドは改行後の先頭に付与され、オペランドの位置は先頭行の変数の頭に整列される
int aaa = bbbbbbbbbbbbbbb
          + ccccccccccccccc;
```

```C++:AlignAfterOperator(BreakBeforeBinaryOperatorsが指定あり)
// オペランドは改行後の先頭に付与され、オペランドの位置は先頭行のオペランドに整列される
int aaa = bbbbbbbbbbbbbbb
        + ccccccccccccccc;
```
</dd></dl>

</dd></dl>
<!-- ***************  AlignOperands END  *************** -->

<!-- ***************  AlignTrailingComments START  *************** -->
<dl><dt>
AlignTrailingComments(Boolean) <font color=green>3.7以降</font>
</dt><dd>
コメントの整列方法を指定する。<br/>
<dl><dd>

```C++:true
// コメントの位置を整列する
int a;     // comment a
int b = 2; // comment b
```
```C++:false
// コメントの位置を整列しない(スペース1個分の位置まで詰める)
int a; // comment a
int b = 2; // comment b
```

</dd></dl>
</dd></dl>
<!-- ***************  AlignTrailingComments END  *************** -->

<!-- ***************  AllowAllArgumentsOnNextLine START  *************** -->
<dl><dt>
AllowAllArgumentsOnNextLine(Boolean) <font color=green>9以降</font>
</dt><dd>
関数の引数や初期化リストが1行に収まらない場合の動作を指定する。BinPackArgumentsにfalseを指定している場合でもこの処理は動作する。<br/>

<dl><dd>

```C++:true
// 関数の引数を1行で記載する
callFunction(
    a, b, c, d);
```
```C++:false
// 関数の引数を複数行で記載する
callFunction(a,
             b,
             c,
             d);
```
:::note info
**メモ書き**
筆者環境にて動作が確認できず。(RHEL9.0、clang-format15)
--style={ BreakBeforeBraces: Linux, BinPackArguments: true/false, AllowAllArgumentsOnNextLine: true/false }で4パターン試行して、どの指定でも変換が行われなかった。
:::

</dd></dl>
</dd></dl>
<!-- ***************  AllowAllArgumentsOnNextLine END  *************** -->


<!-- ***************  AllowAllConstructorInitializersOnNextLine START  *************** -->
<dl><dt>
AllowAllConstructorInitializersOnNextLine(Boolean) <font color=green>9以降</font>
</dt><dd>
非推奨なオプション。PackConstructorInitializersのNextLineを参照すること。<br/>
</dd></dl>
<!-- ***************  AllowAllConstructorInitializersOnNextLine END  *************** -->

<!-- ***************  AllowShortBlocksOnASingleLine START  *************** -->
<dl><dt>
AllowShortBlocksOnASingleLine(ShortBlockStyle) <font color=green>3.5以降</font>
</dt><dd>
短いwhile文( while (true) { continue; } )の並べ方を指定する。<br/>
※ステートメントを波括弧で囲んでいる場合の動作。波括弧を付与しない場合、AllowShortLoopsOnASingleLineにより指定を行う。

| 値       | 意味 |
|:---------|:-----|
| Never    | ブロックを1行に並べない。 |
| Empty    | 空のブロックだけ1行に並べる。 |
| Always   | 短いブロックは1行に並べる。 |
| true     | Alwaysと同じ動作となる。(レガシーオプション) |
| false    | Neverと同じ動作となる。(レガシーオプション) |

<dl><dd>

```C++:Never
// 短いwhile文も必ず折り返す
while (true) {
}
while (true) {
  continue;
}
```
```C++:Empty
// 空のwhile文は1行に纏める
while (true) {}
while (true) {
  continue;
}
```
```C++:Always
// while文を1行に纏める
while (true) {}
while (true) { continue; }
```
</dd></dl>
</dd></dl>
<!-- ***************  AllowShortBlocksOnASingleLine END  *************** -->

<!-- ***************  AllowShortCaseLabelsOnASingleLine START  *************** -->
<dl><dt>
AllowShortCaseLabelsOnASingleLine(Boolean) <font color=green>3.6以降</font>
</dt><dd>
短いcase文のまとめ方を指定する。<br/>

<dl><dd>

```C++:true
// caseラベルとその処理を1行にまとめる
switch (a) {
case 1: x = 1; break;
case 2: return;
}
```
```C++:false
// caseラベルとその処理を1行にまとめない
switch (a) {
case 1:
  x = 1;
  break;
case 2:
  return;
```
</dd></dl>
</dd></dl>
<!-- ***************  AllowShortCaseLabelsOnASingleLine END  *************** -->

<!-- ***************  AllowShortEnumsOnASingleLine START  *************** -->
<dl><dt>
AllowShortEnumsOnASingleLine(Boolean) <font color=green>11以降</font>
</dt><dd>
短い列挙型のまとめ方を指定する。<br/>

<dl><dd>

```C++:true
// 列挙型を1行にまとめる
enum { A, B } myEnum;
}
```
```C++:false
// 列挙型を1行にまとめない
enum {
  A,
  B
} myEnum;
```
</dd></dl>
</dd></dl>
<!-- ***************  AllowShortEnumsOnASingleLine END  *************** -->

<!-- ***************  AllowShortFunctionsOnASingleLine START  *************** -->
<dl><dt>
AllowShortFunctionsOnASingleLine(ShortFunctionStyle) <font color=green>3.5以降</font>
</dt><dd>
短い関数(処理が1行以下)の纏め方を指定する。<br/>

| 値         | 意味 |
|:-----------|:-----|
| None       | 関数を1行に纏めない。 |
| InlineOnly | クラス内で定義した関数だけ1行に纏める。Inlineと同じ動作だが、空の関数についてのみ動作が異なる。 |
| Empty      | 空の関数は1行に纏める。 |
| Inline     | クラス内で定義した関数だけ1行に纏める。 |
| All        | すべての関数を1行に纏める |
| true       | Allと同じ動作となる。(レガシーオプション) |
| false      | Noneと同じ動作となる。(レガシーオプション) |

<dl><dd>

```C++:InlineOnly
// クラスメソッドは1行に纏められる。
class Foo {
  void f1() { foo(); }
};
void f2() {
  foo();
}
// Inlineと異なる箇所
void f3() {
}
```
```C++:Empty
class Foo {
  void f1() {
    foo();
  }
};
void f2() {
  foo();
}
// 空のメソッドだけ1行に纏める
void f3() {}
```
```C++:Inline
// クラスメソッドと空のメソッドが1行に纏められる。
class Foo {
  void f1() { foo(); }
};
void f2() {
  foo();
}
void f3() {}
```
```C++:All
// すべて1行に纏める。
class Foo {
  void f1() { foo(); }
};
void f2() { foo(); }
void f3() {}
```
</dd></dl>
</dd></dl>
<!-- ***************  AllowShortFunctionsOnASingleLine END  *************** -->

<!-- ***************  AllowShortIfStatementsOnASingleLine START  *************** -->
<dl><dt>
AllowShortIfStatementsOnASingleLine(ShortIfStyle) <font color=green>3.3以降</font>
</dt><dd>
短いif及びelseの纏め方を指定する。<br/>

| 値            | 意味 |
|:--------------|:----|
| Never         | 短いifを同じ行に並べない。 |
| WithoutElse   | else文がない場合のみ、短いifを同じ行に並べる。 |
| OnlyFirstIf   | 短いifだけを並べる。else ifやelse文は並べない。 |
| AllIfsAndElse | 短いif、else if及びelse文を同じ行に並べる。 |
| Always        | OnlyFirstIfと同じ動作となる。(レガシーオプション)  |
| true          | WithoutElseと同じ動作となる。(レガシーオプション)  |
| false         | Neverと同じ動作となる。(レガシーオプション)  |

<dl><dd>

```C++:Never
if (a)
  return;

if (b)
  return;
else
  return;

if (c)
  return;
else {
  return;
}
```
```C++:WithoutElse
// ifだけの場合、1行に纏める。
if (a) return;

if (b)
  return;
else
  return;

if (c)
  return;
else {
  return;
}
```
```C++:AllIfsAndElse
// すべて1行に纏める。
if (a) return;

if (b) return;
else return;

if (c) return;
else {
  return;
}
```
</dd></dl>
</dd></dl>
<!-- ***************  AllowShortIfStatementsOnASingleLine END  *************** -->

<!-- ***************  AllowShortIfStatementsOnASingleLine START  *************** -->
<dl><dt>
AllowShortIfStatementsOnASingleLine(ShortLambdaStyle) <font color=green>9以降</font>
</dt><dd>
短いラムダ式の纏め方を指定する。<br/>

| 値     | 意味 |
|:-------|:----|
| None   | 短いラムダ式を同じ行に並べない。 |
| Empty  | 空のラムダ式だけ1行に並べる。 |
| Inline | 関数の引数として指定したラムダ式だけ1行に並べる。 |
| All    | すべての短いラムダ式を1行に並べる。 |
| true   | Allと同じ動作となる。(レガシーオプション) |
| false  | Noneと同じ動作となる。(レガシーオプション) |

<dl><dd>

```C++:Empty
// 空のラムダ式だけ1行に並べる。
auto lambda = [](int a) {};
auto lambda2 = [](int a) {
  return a;
};
sort(vct.begin(), vct.end(), [](int x, int y) {
  return x < y;
});
```
```C++:Inline
auto lambda = [](int a) {
};
auto lambda2 = [](int a) {
  return a;
};
// 関数の引数として指定したラムダ式だけ1行に並べる。
sort(vct.begin(), vct.end(), [](int x, int y) { return x < y; });
```
```C++:All
// すべての短いラムダ式を1行に並べる。
auto lambda = [](int a) {};
auto lambda2 = [](int a) { return a; };
sort(vct.begin(), vct.end(), [](int x, int y) { return x < y; });
```
</dd></dl>
</dd></dl>
<!-- ***************  AllowShortIfStatementsOnASingleLine END  *************** -->

<!-- ***************  AllowShortLoopsOnASingleLine START  *************** -->
<dl><dt>
AllowShortLoopsOnASingleLine(Boolean) <font color=green>3.7以降</font>
</dt><dd>
短いwhile文( while (true) continue; )の並べ方を指定する。<br/>
※ステートメントを波括弧で囲んでいない場合の動作。波括弧を付与する場合、AllowShortBlocksOnASingleLine により指定を行う。

<dl><dd>

```C++:true
while (true) { continue; }
```
```C++:false
while (true) {
  continue;
}
```
</dd></dl>
</dd></dl>
<!-- ***************  AllowShortLoopsOnASingleLine END  *************** -->

<!-- ***************  AlwaysBreakAfterDefinitionReturnType START  *************** -->
<dl><dt>
AlwaysBreakAfterDefinitionReturnType(DefinitionReturnTypeBreakingStyle) <font color=green>3.7以降</font>
</dt><dd>
非推奨なオプション。
</dd></dl>
<!-- ***************  AlwaysBreakAfterDefinitionReturnType END  *************** -->

<!-- ***************  AlwaysBreakAfterReturnType START  *************** -->
<dl><dt>
AlwaysBreakAfterReturnType(ReturnTypeBreakingStyle) <font color=green>3.8以降</font>
</dt><dd>
関数の戻り値の改行スタイルを指定する。<br/>

| 値       | 意味 |
|:---------|:----|
| None     | 戻り値を改行しない。 |
| All      | 戻り値の後で必ず改行する。 |
| TopLevel | トップレベルの関数だけ、戻り値の後で改行する。|
| AllDefinitions| 関数の実体定義だけ、戻り値の後で改行する。 |
| TopLevelDefinitions| トップレベルの関数の実体定義だけ、戻り値の後で改行する。 |
| true     | Allと同じ動作となる。(レガシーオプション) |
| false    | Noneと同じ動作となる。(レガシーオプション) |

<dl><dd>

```C++:None
class B {
  int f() { return 0; };
};
int f();
int f() { return 1; }
```
```C++:All
class B {
  int
  f() {
    return 0;
  };
};
int
f();
int
f() {
  return 1;
}
```
```C++:TopLevel
class B {
  int f() { return 0; };
};
// トップレベルのメソッド(クラススコープのメソッドではない？)は改行する。
int
f();
int
f() {
  return 1;
}
```
```C++:AllDefinitions
// 関数の実体定義がある場合は改行する。
class B {
  int
  f() {
    return 0;
  };
};
int f();
int
f() {
  return 1;
}
```
</dd></dl>
</dd></dl>
<!-- ***************  AlwaysBreakAfterReturnType END  *************** -->

<!-- ***************  AlwaysBreakBeforeMultilineStrings START  *************** -->
<dl><dt>
AlwaysBreakBeforeMultilineStrings(Boolean) <font color=green>3.4以降</font>
</dt><dd>
文字列リテラルの並べ方を指定する。<br/>
ContinuationIndentWidthが未指定の場合だけ、このフラグが有効となる。

<dl><dd>

```C++:true
const char *sz =
    "aaaa"
    "bbbb";
```
```C++:false
const char *sz = "aaaa"
                 "bbbb";
```
</dd></dl>
</dd></dl>
<!-- ***************  AlwaysBreakBeforeMultilineStrings END  *************** -->

<!-- ***************  AlwaysBreakTemplateDeclarations START  *************** -->
<dl><dt>
AlwaysBreakTemplateDeclarations(BreakTemplateDeclarationsStyle) <font color=green>3.4以降</font>
</dt><dd>
テンプレート宣言の改行スタイルを指定する。<br/>

| 値        | 意味 |
|:----------|:----|
| No        | テンプレート宣言の後に改行を行わない。 |
| MultiLine | テンプレート宣言の後が複数行になる場合だけ改行を行う |
| Yes       | 必ずテンプレート宣言の後に改行を行う。  |
| false     | MultiLineと同じ動作となる。(レガシーオプション) |
| true      | Yesと同じ動作となる。(レガシーオプション)  |

<dl><dd>

```C++:No
template <typename T> T foo() {
}
template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,
                            int bbbbbbbbbbbbbbbbbbbbb) {
}
```
```C++:MultiLine
template <typename T> T foo() {
}
// テンプレート宣言の後ろに複数行ある場合だけ改行を行う
template <typename T>
T foo(int aaaaaaaaaaaaaaaaaaaaa,
      int bbbbbbbbbbbbbbbbbbbbb) {
}
```
```C++:Yes
// テンプレート宣言の後は必ず改行する
template <typename T>
T foo() {
}
template <typename T>
T foo(int aaaaaaaaaaaaaaaaaaaaa,
      int bbbbbbbbbbbbbbbbbbbbb) {
```
</dd></dl>
</dd></dl>
<!-- ***************  AlwaysBreakTemplateDeclarations END  *************** -->

<!-- ***************  AttributeMacros START  *************** -->
<dl><dt>
AttributeMacros(List of Strings) <font color=green>12以降</font>
</dt><dd>
識別子ではなく、属性/修飾子として解釈されるべき文字列のリストを指定する。<br/>
つまり、このリストで指定したキーワードは属性/修飾子としてフォーマットが行われる。<br/>
<br/>
.clang-format 設定ファイルでは、次の様に設定することができる。
<dl><dd>

```yaml:
AttributeMacros: ['__capability', '__output', '__ununsed']
```
</dd></dl>
</dd></dl>
<!-- ***************  AttributeMacros END  *************** -->

<!-- ***************  BinPackArguments START  *************** -->
<dl><dt>
BinPackArguments(Boolean) <font color=green>3.7以降</font>
</dt><dd>
関数の引数の並べ方を指定する。<br/>

<dl><dd>

```C++:true
// 1行の最大文字数を基準に折り返しを行う
void f() {
  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
}
```
```C++:false
// 引数を各1行ずつに折り返す
void f() {
  f(aaaaaaaaaaaaaaaaaaaa,
    aaaaaaaaaaaaaaaaaaaa,
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
}
```
</dd></dl>
</dd></dl>
<!-- ***************  BinPackArguments END  *************** -->

<!-- ***************  BinPackParameters START  *************** -->
<dl><dt>
BinPackParameters(Boolean) <font color=green>3.7以降</font>
</dt><dd>
関数宣言や関数定義の引数の並べ方を指定する。<br/>

<dl><dd>

```C++:true
// 1行の最大文字数を基準に折り返しを行う
void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
```
```C++:false
// 引数を各1行ずつに折り返す
void f(int aaaaaaaaaaaaaaaaaaaa,
       int aaaaaaaaaaaaaaaaaaaa,
       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
```
</dd></dl>
</dd></dl>
<!-- ***************  BinPackParameters END  *************** -->


<!-- ***************  BitFieldColonSpacing START  *************** -->
<dl><dt>
BitFieldColonSpacing(BitFieldColonSpacingStyle) <font color=green>12以降</font>
</dt><dd>
テンプレート宣言の改行スタイルを指定する<br/>

| 値        | 意味 |
|:----------|:----|
| Both      | コロンの前後にスペースを挿入する。 |
| None      | コロンの前後にスペースを挿入しない。 |
| Before    | コロンの前だけスペースを挿入する。 |
| After     | コロンの後ろだけスペースを挿入する。 |

<dl><dd>

```C++:Both
unsigned bf : 2;
```
```C++:None
unsigned bf:2;
```
```C++:Before
unsigned bf :2;
```
```C++:After
unsigned bf: 2;
```
</dd></dl>
</dd></dl>
<!-- ***************  BitFieldColonSpacing END  *************** -->

<!-- ***************  BraceWrapping START  *************** -->
<dl><dt>
BraceWrapping (BraceWrappingFlags) <font color=green>3.8以降</font>
</dt><dd>
括弧の個別制御を指定する。このフラグはBreakBeforeBracesがBS_Customに設定されている場合だけ有効で、それ以外の場合は無視される。

<dl><dd>

```C++:.clang-formatの書式例
BreakBeforeBraces: Custom
BraceWrapping:
  AfterEnum: true
  AfterStruct: false
  SplitEmptyFunction: false
```
</dd></dl>

 各設定フラグについては以下のとおり。

<!-- ***************  BraceWrapping:AfterCaseLabel START  *************** -->
<dl><dt>
AfterCaseLabel(Boolean)
</dt><dd>
caseラベルに対する括弧の制御方法を指定する。
<dl><dd>

```C++: true
  // caseラベルの後ろの括弧は改行する
  switch (foo) {
    case 1:
    {
      bar();
      break;
    }
    default:
    {
      plop();
    }
  }
```

```C++:false
  // caseラベルの後ろの括弧は改行しない
  switch (foo) {
    case 1: {
      bar();
      break;
    }
    default: {
      plop();
    }
  }
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:AfterCaseLabel END  *************** -->

<!-- ***************  BraceWrapping:AfterClass START  *************** -->
<dl><dt>
AfterClass(Boolean)
</dt><dd>
クラス定義に対する括弧の制御方法を指定する。
<dl><dd>

```C++: true
// 後ろの括弧は改行する
class foo
{};
```

```C++:false
// 後ろの括弧は改行しない
class foo {};
```

</dd></dl>

:::note info
**メモ書き**
公式ドキュメントに誤記あり。
trueとfalseの動作が逆に記載されている。
:::

</dd></dl>
<!-- ***************  BraceWrapping:AfterClass END  *************** -->

<!-- ***************  BraceWrapping:AfterControlStatement START  *************** -->
<dl><dt>AfterControlStatement(BraceWrappingAfterControlStatementStyle)
</dt><dd>
ステートメント(if、for、while、switch等)に対する括弧の制御方法を指定する。

| 値    | 意味 |
|:------|:----|
| Never| 制御文の後の波括弧を改行しない。 |
| MultiLine| 複数行の制御文の後の波括弧だけ改行する。 |
| Always| 制御文の後の波括弧を改行する。 |
| false| Neverと同じ動作となる。(レガシーオプション) |
| true| Alwaysと同じ動作となる。(レガシーオプション)  |

<dl><dd>

```C++:Never
  // 制御文の後の波括弧を改行しない。
  if (foo()) {
  } else {
  }
  for (int i = 0; i < 10; ++i) {
  }
```

```C++:MultiLine
  // 複数行の制御文の後の波括弧だけ改行する。
  if (foo && bar &&
      baz)
  {
    quux();
  }
  while (foo || bar) {
  }
```

```C++:Always
  // 制御文の後の波括弧を改行する。
  if (foo())
  {
  } else
  {}
  for (int i = 0; i < 10; ++i)
  {}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:AfterControlStatement END  *************** -->

<!-- ***************  BraceWrapping:AfterEnum START  *************** -->
<dl><dt>AfterEnum(Boolean)
</dt><dd>
列挙型に対する括弧の制御方法を指定する。
<dl><dd>

```C++: true
// 後ろの括弧は改行する
enum X : int
{
  B
};
```
```C++:false
// 後ろの括弧は改行しない
enum X : int { B };
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:AfterEnum END  *************** -->


<!-- ***************  BraceWrapping:AfterFunction START  *************** -->
<dl><dt>
AfterFunction(Boolean)
</dt><dd>
関数に対する括弧の制御方法を指定する。
<dl><dd>

```C++: true
// 後ろの括弧は改行する
void foo()
{
  bar();
  bar2();
}
```
```C++:false
// 後ろの括弧は改行しない
void foo() {
  bar();
  bar2();
}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:AfterFunction END  *************** -->

<!-- ***************  BraceWrapping:AfterNamespace START  *************** -->
<dl><dt>
AfterNamespace(Boolean)
</dt><dd>
名前空間に対する括弧の制御方法を指定する。
<dl><dd>

```C++: true
// 後ろの括弧は改行する
namespace
{
int foo();
int bar();
}
```
```C++:false
// 後ろの括弧は改行しない
namespace {
int foo();
int bar();
}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:AfterNamespace END  *************** -->

<!-- ***************  BraceWrapping:AfterObjCDeclaration START  *************** -->
<dl><dt>
AfterObjCDeclaration(Boolean)
</dt><dd>
Objective-Cの定義(<span>@</span>interface、<span>@</span>implementation等)、<span>@</span>autoreleasepool及び<span>@</span>synchronizedに対する括弧の制御方法を指定する。

<dl><dd>

```Objective-C:true
// 後ろの括弧は改行する
@interface MyObject : NSObject
{
  int val;
}
```
```Objective-C:false
// 後ろの括弧は改行しない
@interface MyObject : NSObject {
  int val;
}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:AfterObjCDeclaration END  *************** -->

<!-- ***************  BraceWrapping:AfterStruct START  *************** -->
<dl><dt>
AfterStruct(Boolean)
</dt><dd>
構造体に対する括弧の制御方法を指定する。
<dl><dd>

```C++:true
// 後ろの括弧は改行する
struct foo
{
  int x;
};
```
```C++:false
// 後ろの括弧は改行しない
struct foo {
  int x;
};
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:AfterStruct END  *************** -->

<!-- ***************  BraceWrapping:AfterUnion START  *************** -->
<dl><dt>
AfterUnion(Boolean)
</dt><dd>
共用体に対する括弧の制御方法を指定する。
<dl><dd>

```C++:true
// 後ろの括弧は改行する
union foo
{
  int x;
}
```
```C++:false
// 後ろの括弧は改行しない
union foo {
  int x;
}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:AfterUnion END  *************** -->

<!-- ***************  BraceWrapping:AfterExternBlock START  *************** -->
<dl><dt>
AfterExternBlock(Boolean)
</dt><dd>
外部結合ブロック(extern)に対する括弧の制御方法を指定する。
<dl><dd>

```C++:true
// 後ろの括弧は改行する
extern "C"
{
  int foo();
}
```
```C++:false
// 後ろの括弧は改行しない
extern "C" {
int foo();
}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:AfterExternBlock END  *************** -->

<!-- ***************  BraceWrapping:BeforeCatch START  *************** -->
<dl><dt>
BeforeCatch(Boolean)
</dt><dd>
catch句の前方の括弧の制御方法を指定する。
<dl><dd>

```C++:true
// 前方の括弧は改行する
try {
  foo();
}
catch () {
}
```
```C++:false
// 前方の括弧は改行しない
try {
  foo();
} catch () {
}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:BeforeCatch END  *************** -->

<!-- ***************  BraceWrapping:BeforeElse START  *************** -->
<dl><dt>
BeforeElse(Boolean)
</dt><dd>
else句の前方の括弧の制御方法を指定する。
<dl><dd>

```C++:true
// 前方の括弧は改行する
if (foo()) {
}
else {
}
```
```C++:false
// 前方の括弧は改行しない
if (foo()) {
} else {
}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:BeforeElse END  *************** -->

<!-- ***************  BraceWrapping:BeforeLambdaBody START  *************** -->
<dl><dt>
BeforeLambdaBody(Boolean)
</dt><dd>
ラムダ式の前方の括弧の制御方法を指定する。
<dl><dd>

```C++:true
// 前方の括弧は改行する(キャプチャとラムダ導入子も改行される？)
connect(
  []()
  {
    foo();
    bar();
  });
```
```C++:false
// 前方の括弧は改行しない
connect([]() {
  foo();
  bar();
});
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:BeforeLambdaBody END  *************** -->

<!-- ***************  BraceWrapping:BeforeWhile START  *************** -->
<dl><dt>
BeforeWhile(Boolean)
</dt><dd>
do～whileの前方の括弧の制御方法を指定する。
<dl><dd>

```C++:true
// 前方の括弧は改行する
do {
  foo();
}
while (1);
```
```C++:false
// 前方の括弧は改行しない
do {
  foo();
} while (1);
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:BeforeWhile END  *************** -->

<!-- ***************  BraceWrapping:IndentBraces START  *************** -->
<dl><dt>
IndentBraces(Boolean)
</dt><dd>
折り返した波括弧のインデントの可否を指定する。
<dl><dd>

```C++:true
// 折り返した波括弧をインデントする
if (a) {
    foo(a,b);
} else {
  }
for (int i = 0; i < 10; ++i) {
  }
```
```C++:false
// 折り返した波括弧をインデントしない
if (a) {
  foo(a, b);
} else {
}
for (int i = 0; i < 10; ++i) {
}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:IndentBraces END  *************** -->

<!-- ***************  BraceWrapping:SplitEmptyFunction START  *************** -->
<dl><dt>
SplitEmptyFunction(Boolean)
</dt><dd>
空の関数本体を1行に纏めるかを指定する。このオプションはAllowShortFunctionsOnASingleLine にNone、AfterFunctionにtrueを指定している場合のみ適用されます。
<dl><dd>

```C++:true
// 空の関数の括弧を1行に並べない。
int f()
{
}
```
```C++:false
// 空の関数の括弧を1行に並べる。
int f()
{}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:SplitEmptyFunction END  *************** -->

<!-- ***************  BraceWrapping:SplitEmptyRecord START  *************** -->
<dl><dt>
SplitEmptyRecord(Boolean)
</dt><dd>
空のクラス本体を1行に纏めるかを指定する。AfterClassにtrueを指定している場合のみ適用されます。
<dl><dd>

```C++:true
// 空のクラスの括弧を1行に並べない。
class Foo
{
}
```
```C++:false
// 空のクラスの括弧を1行に並べる。
class Foo
{}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:SplitEmptyRecord END  *************** -->

<!-- ***************  BraceWrapping:SplitEmptyNamespace START  *************** -->
<dl><dt>
SplitEmptyNamespace(Boolean)
</dt><dd>
空の名前空間本体を1行に纏めるかを指定する。AfterNamespaceにtrueを指定している場合のみ適用されます。
<dl><dd>

```C++:true
// 空のクラスの括弧を1行に並べない。
namespace Foo
{
}
```
```C++:false
// 空のクラスの括弧を1行に並べる。
namespace Foo
{}
```
</dd></dl>
</dd></dl>
<!-- ***************  BraceWrapping:SplitEmptyNamespace END  *************** -->

</dd></dl>
<!-- BraceWrapping END -->

<!-- ***************  BreakAfterJavaFieldAnnotations START  *************** -->
<dl><dt>
BreakAfterJavaFieldAnnotations(Boolean) <font color=green>3.8以降</font>
</dt><dd>
Javaファイルのアノテーションの改行を指定する。
<dl><dd>

```java:true
// アノテーションで改行する
@Partial
@Mock
DataLoad loader;
```
```java:false
// アノテーションで改行しない
@Partial @Mock DataLoad loader;
```
</dd></dl>
</dd></dl>
<!-- ***************  BreakAfterJavaFieldAnnotations END  *************** -->

<!-- ***************  BreakBeforeBinaryOperators START  *************** -->
<dl><dt>
BreakBeforeBinaryOperators(BinaryOperatorStyle) <font color=green>3.6以降</font>
</dt><dd>
二項演算子の並べ方を指定する。

| 値             | 意味 |
|:---------------|:-----|
| None           | 演算子の後で改行する。 |
| NonAssignment  | 代入ではない演算子の前で改行する。 |
| All            | 演算子の前で改行する。|
| true           | Allと同じ動作。 |
| false          | Noneと同じ動作。 |

<dl><dd>

```C++:None
// 演算子の後で改行する。
LooooooooooongType loooooooooooooooooooooongVariable =
    someLooooooooooooooooongFunction();

bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
                 ccccccccccccccccccccccccccccccccccccccccc;
```
```C++:NonAssignment
// 代入ではない演算子の後で改行する。
LooooooooooongType loooooooooooooooooooooongVariable =
    someLooooooooooooooooongFunction();

bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                    > ccccccccccccccccccccccccccccccccccccccccc;
```
```C++:All
// 演算子の前で改行する。
LooooooooooongType loooooooooooooooooooooongVariable
    = someLooooooooooooooooongFunction();

bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                    > ccccccccccccccccccccccccccccccccccccccccc;
```
</dd></dl>

:::note info
**メモ書き**
NonAssignmentとAllの挙動が理解できない。改行位置はわかるがインデントはどうしてこの動作になるのか。(実動作を確認の結果、記載のインデントになる)
:::

</dd></dl>
<!-- ***************  BreakAfterJavaFieldAnnotations END  *************** -->

<!-- ***************  BreakBeforeBraces START  *************** -->
<dl><dt>
BreakBeforeBraces(BraceBreakingStyle) <font color=green>3.7以降</font>
</dt><dd>
括弧の制御を一括で指定する。

| 値             | 意味 |
|:---------------|:-----|
| Attach         | 文脈の後に括弧を並べる。 |
| Linux          | Attachと同様。ただし関数、名前空間、クラス定義(C#のレコード型を含む)の括弧は改行する。 |
| Mozilla        | Attachと同様。ただし列挙型、関数、名前空間、クラス定義(C#のレコード型を含む)の括弧は改行する。 |
| Stroustrup     | Attachと同様。ただし関数定義、catch、elseの前の括弧は改行する。 |
| Allman         | 文脈の後の括弧を改行する。|
| Whitesmiths    | Allmanと同様。ただし波括弧にインデントを付ける。 |
| GNU            | Allmanと同様。ただし制御文の波括弧にインデントを付ける。 |
| WebKit         | Attachと同様。ただし関数の括弧は改行する。 |
| Custom         | BraceWrappingフラグにより個々の改行ルールを決定する。(BraceWrappingの項を参照) |

<dl><dd>

```C++:Attach
namespace N {
enum E {
  E1,
  E2,
};

class C {
public:
  C();
};

bool baz(int i) {
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  } catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b) {
  if (b) {
    baz(2);
  } else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N
```
```C++:Linux
namespace N
{
enum E {
  E1,
  E2,
};

class C
{
public:
  C();
};

bool baz(int i)
{
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  } catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b) {
    baz(2);
  } else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N
```
```C++:Mozilla
namespace N {
enum E
{
  E1,
  E2,
};

class C
{
public:
  C();
};

bool baz(int i)
{
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  } catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b) {
    baz(2);
  } else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N
```
```C++:Stroustrup
namespace N {
enum E {
  E1,
  E2,
};

class C {
public:
  C();
};

bool baz(int i)
{
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  }
  catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b) {
    baz(2);
  }
  else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N
```
```C++:Allman
namespace N
{
enum E
{
  E1,
  E2,
};

class C
{
public:
  C();
};

bool baz(int i)
{
  try
  {
    do
    {
      switch (i)
      {
      case 1:
      {
        foobar();
        break;
      }
      default:
      {
        break;
      }
      }
    } while (--i);
    return true;
  }
  catch (...)
  {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b)
  {
    baz(2);
  }
  else
  {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N
```
```C++:Whitesmiths
namespace N
  {
enum E
  {
  E1,
  E2,
  };

class C
  {
public:
  C();
  };

bool baz(int i)
  {
  try
    {
    do
      {
      switch (i)
        {
        case 1:
        {
        foobar();
        break;
        }
        default:
        {
        break;
        }
        }
      } while (--i);
    return true;
    }
  catch (...)
    {
    handleError();
    return false;
    }
  }

void foo(bool b)
  {
  if (b)
    {
    baz(2);
    }
  else
    {
    baz(5);
    }
  }

void bar() { foo(true); }
  } // namespace N
```
```C++:GNU
namespace N
{
enum E
{
  E1,
  E2,
};

class C
{
public:
  C();
};

bool baz(int i)
{
  try
    {
      do
        {
          switch (i)
            {
            case 1:
              {
                foobar();
                break;
              }
            default:
              {
                break;
              }
            }
        }
      while (--i);
      return true;
    }
  catch (...)
    {
      handleError();
      return false;
    }
}

void foo(bool b)
{
  if (b)
    {
      baz(2);
    }
  else
    {
      baz(5);
    }
}

void bar() { foo(true); }
} // namespace N
```
```C++:WebKit
namespace N {
enum E {
  E1,
  E2,
};

class C {
public:
  C();
};

bool baz(int i)
{
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  } catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b) {
    baz(2);
  } else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N
```

</dd></dl>
</dd></dl>
<!-- ***************  BreakBeforeBraces END  *************** -->

<!-- ***************  BreakBeforeConceptDeclarations START  *************** -->
<dl><dt>
BreakBeforeConceptDeclarations(BreakBeforeConceptDeclarationsStyle) <font color=green>12以降</font>
</dt><dd>
コンセプトに対する括弧の制御方法を指定する。

| 値             | 意味 |
|:---------------|:-----|
| Never          | テンプレート宣言とコンセプトを並べる。 |
| Allowed        | 他のフラグ指定に従い、テンプレート宣言の後に改行を行うことが可能。指定がない場合、テンプレート宣言とコンセプトを並べる。 |
| Always         | コンセプトの前で改行する。|
| true           | Alwaysと同じ動作。(レガシーオプション) |
| false          | Allowedと同じ動作。(レガシーオプション) |

<dl><dd>

```C++:Never
template <class T> concept Foo = requires(T &x) {};
```
```C++:Always
template <class T>
concept Foo = requires(T &x) {};
```
</dd></dl>
</dd></dl>
<!-- ***************  BreakBeforeConceptDeclarations END  *************** -->

<!-- ***************  BreakBeforeTernaryOperators START  *************** -->
<dl><dt>
BreakBeforeTernaryOperators(Boolean) <font color=green>3.7以降</font>
</dt><dd>
1行に収まらない三項演算子に対する括弧の制御方法を指定する。

<dl><dd>

```C++:true
// 演算子の前で改行を行う
veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
    ? firstValue
    : SecondValueVeryVeryVeryVeryLong;
```
```C++:false
// 演算子の後で改行を行う
veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
    firstValue :
    SecondValueVeryVeryVeryVeryLong;
```
</dd></dl>
</dd></dl>
<!-- ***************  BreakBeforeTernaryOperators END  *************** -->

<!-- ***************  BreakConstructorInitializers START  *************** -->
<dl><dt>
BreakConstructorInitializers(BreakConstructorInitializersStyle) <font color=green>5以降</font>
</dt><dd>
コンストラクタの初期化リストに対する制御方法を指定する。

| 値             | 意味 |
|:---------------|:-----|
| BeforeColon    | コロンの前とカンマの後で改行する。 |
| BeforeComma    | コロンとカンマの前で改行し、コロンとカンマの位置を合わせる。 |
| AfterColon     | コロンとカンマの後で改行する。|

<dl><dd>

```C++:BeforeColon
Constructor()
    : initializer1(),
      initializer2()
```
```C++:BeforeComma
Constructor()
    : initializer1()
    , initializer2()
```
```C++:AfterColon
Constructor() :
    initializer1(),
    initializer2()
```
</dd></dl>
</dd></dl>
<!-- ***************  BreakConstructorInitializers END  *************** -->

<!-- ***************  BreakInheritanceList START  *************** -->
<dl><dt>
BreakInheritanceList(BreakInheritanceListStyle) <font color=green>7以降</font>
</dt><dd>
継承リストに対する制御方法を指定する。

| 値             | 意味 |
|:---------------|:-----|
| BeforeColon    | コロンの前とカンマの後で改行する。 |
| BeforeComma    | コロンとカンマの前で改行し、コロンとカンマの位置を合わせる。 |
| AfterColon     | コロンとカンマの後で改行する。|
| AfterComma     | カンマの後で改行する。|

<dl><dd>

```C++:BeforeColon
class Foo
    : Base1,
      Base2
{};
```
```C++:BeforeComma
class Foo
    : Base1
    , Base2
{};
```
```C++:AfterColon
class Foo :
    Base1,
    Base2
{};
```
```C++:AfterComma
class Foo : Base1,
            Base2
{};
```
</dd></dl>
</dd></dl>
<!-- ***************  BreakInheritanceList END  *************** -->

<!-- ***************  BreakStringLiterals START  *************** -->
<dl><dt>
BreakStringLiterals(Boolean) <font color=green>3.9以降</font>
</dt><dd>
1行に収まらない文字列リテラルに対する制御方法を指定する。

<dl><dd>

```C++:true
// 1行の最大文字数で文字列リテラルを分割する
const char* x = "veryVeryVeryVeryVeryVe"
                "ryVeryVeryVeryVeryVery"
                "VeryLongString";
```
```C++:false
// 文字列リテラルを分割しない
const char* x =
  "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";
```

</dd></dl>

:::note info
**メモ書き**
一度、BreakStringLiteralsをtrueに指定し文字列リテラルを整形したのち、falseを指定してフォーマットしなおした場合、分割された文字列リテラルは自動で繋がらない。(元に戻らない)
:::

</dd></dl>
<!-- ***************  BreakStringLiterals END  *************** -->

<!-- ***************  ColumnLimit START  *************** -->
<dl><dt>
ColumnLimit(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
1行の最大文字数を指定する。<br/>
0を指定した場合、ステートメント内で他のルールと矛盾しない限り無制限となる。
</dd></dl>
<!-- ***************  ColumnLimit END  *************** -->

<!-- ***************  CommentPragmas START  *************** -->
<dl><dt>
CommentPragmas(String) <font color=green>3.7以降</font>
</dt><dd>
行分割してはいけないコメントを、正規表現で指定する。<br/>
<dl><dd>

```C++:例
// CommentPragmas: '^ FOOBAR pragma:'
// 上記の値を指定した場合、以下の行は改行されない。
#include <vector> // FOOBAR pragma: keep
```
</dd></dl>
</dd></dl>
<!-- ***************  CommentPragmas END  *************** -->

<!-- ***************  CompactNamespaces START  *************** -->
<dl><dt>
CompactNamespaces(boolean) <font color=green>5以降</font>
</dt><dd>
連続した名前空間に対する制御方法を指定する。<br/>
<dl><dd>

```C++:true
// 連続した名前空間を改行しない。
namespace Foo { namespace Bar {
}}

// ただし、1行に収まらない場合、改行が行われる。
namespace Foo { namespace Bar {
namespace Extra {
}}}
```
```C++:false
// 連続した名前空間を改行する。
namespace Foo {
namespace Bar {
}
}
```
</dd></dl>
</dd></dl>
<!-- ***************  CompactNamespaces END  *************** -->

<!-- ***************  ConstructorInitializerAllOnOneLineOrOnePerLine START  *************** -->
<dl><dt>
ConstructorInitializerAllOnOneLineOrOnePerLine(Boolean) <font color=green>3.7以降</font>
</dt><dd>
非推奨のオプション。CurrentLine又はPackConstructorInitializersを参照。<br/>
</dd></dl>
<!-- ***************  ConstructorInitializerAllOnOneLineOrOnePerLine END  *************** -->

<!-- ***************  ConstructorInitializerIndentWidth START  *************** -->
<dl><dt>
ConstructorInitializerIndentWidth(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
コンストラクタの初期化リスト及び継承リストのインデントを指定する。<br/>
</dd></dl>
<!-- ***************  ConstructorInitializerIndentWidth END  *************** -->

<!-- ***************  ContinuationIndentWidth START  *************** -->
<dl><dt>
ContinuationIndentWidth(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
連続する行のインデントを指定する。<br/>

<dl><dd>

```C++:例
// ContinuationIndentWidth: 2 を指定した場合、連続した記述についてインデントが2ずつ付与される。
int i =         //  VeryVeryVeryVeryVeryLongComment
  longFunction( // Again a long comment
    arg);
```
</dd></dl>
</dd></dl>
<!-- ***************  ContinuationIndentWidth END  *************** -->

<!-- ***************  Cpp11BracedListStyle START  *************** -->
<dl><dt>
Cpp11BracedListStyle(Boolean) <font color=green>3.4以降</font>
</dt><dd>
C++11の初期化リストのフォーマットを指定する。<br/>
【重要な相違点】<br/>
trueを指定した場合、<br/>
・波括弧付きリストの内部に空白を入れない。<br/>
・閉じ波括弧の前に改行しない。<br/>
・ブロック・インデントではなく、継続インデントでインデントする。<br/>
となる。<br/>
<br/>
基本的に、C++11 の初期化リストは、関数呼び出しと全く同じ書式で記述されます。初期化リストが名前（例えば型名や変数名）の後にある場合、clang-formatは{}をその名前を持つ関数呼び出しの括弧であるかのようにフォーマットします。もし名前がなければ、長さ0の名前と見なします。

<dl><dd>

```C++:true
// 初期化リストの開き括弧の後と閉じ括弧の前に空白を挿入しない。
vector<int> x{1, 2, 3, 4};
vector<T> x{{}, {}, {}, {}};
f(MyMap[{composite, key}]);
new int[3]{1, 2, 3};
```
```C++:false
// 初期化リストの開き括弧の後と閉じ括弧の前に空白を挿入する。
vector<int> x{ 1, 2, 3, 4 };
vector<T> x{ {}, {}, {}, {} };
f(MyMap[{ composite, key }]);
new int[3]{ 1, 2, 3 };
```
</dd></dl>
</dd></dl>
<!-- ***************  Cpp11BracedListStyle END  *************** -->

<!-- ***************  DeriveLineEnding START  *************** -->
<dl><dt>
DeriveLineEnding(Boolean) <font color=green>10以降</font>
</dt><dd>
改行コードをCR+LF又はLFに統一する。<br/>
DeriveLineEndingにtrueを指定した場合、ファイル内で一番多い改行コードでファイルの改行を統一する。
DeriveLineEndingにfalseを指定した場合、UseCRLFがtrueであればファイルの改行コードをCR+LFで統一し、UseCRLFがfalseであればDeriveLineEndingにtrueを指定した場合と同じ動作となる。

</dd></dl>
<!-- ***************  DeriveLineEnding END  *************** -->

<!-- ***************  DerivePointerAlignment START  *************** -->
<dl><dt>
DerivePointerAlignment(Boolean) <font color=green>3.7以降</font>
</dt><dd>
参照(&)及びポインタ(*)の位置を統一する。<br/>
trueを指定した場合、ファイル内で一番記述の参照及びポインタの書式に統一する。
falseを指定した場合、PointerAlignmentで指定した値に従い書式を変更する。PointerAlignmentの指定がない場合、trueと同じ動作となる。
<dl><dd>

```C++:例
int* p1 = NULL; // データ型に*が寄せられている
int &r1 = d;    // 変数名に&が寄せられている
int *p2 = NULL; // 変数名に*が寄せられている
↓ // DerivePointerAlignment: true を指定した場合
int *p1 = NULL; // 多数決(2対1)で変数名に寄せているパターンが多いので変数名側に統一される。
int &r1 = d;
int *p2 = NULL;

```
</dd></dl>
</dd></dl>
<!-- ***************  DerivePointerAlignment END  *************** -->

<!-- ***************  DisableFormat START  *************** -->
<dl><dt>
DisableFormat(Boolean) <font color=green>3.7以降</font>
</dt><dd>
フォーマットを無効にする。<br/>
</dd></dl>
<!-- ***************  DisableFormat END  *************** -->

<!-- ***************  EmptyLineAfterAccessModifier START  *************** -->
<dl><dt>
EmptyLineAfterAccessModifier(EmptyLineAfterAccessModifierStyle) <font color=green>13以降</font>
</dt><dd>
アクセス修飾子の後に対する制御方法を指定する。

| 値             | 意味 |
|:---------------|:-----|
| Never          | アクセス修飾子の後の空行をすべて削除する。 |
| Leave          | アクセス修飾子の後の空行を削除しない。代わりにMaxEmptyLinesToKeepによる制御が行われる。  |
| Always         | アクセス修飾子の後の空行を追加する。MaxEmptyLinesToKeepによる制御も同時に適用される。|

<dl><dd>

```C++:Never
struct foo {
private:
  int i;
protected:
  int j;
  /* comment */
public:
  foo() {}
private:
protected:
};
```
```C++:Always
struct foo {
private:

  int i;
protected:

  int j;
  /* comment */
public:

  foo() {}
private:

protected:

};
```
</dd></dl>
</dd></dl>
<!-- ***************  EmptyLineAfterAccessModifier END  *************** -->

<!-- ***************  EmptyLineBeforeAccessModifier START  *************** -->
<dl><dt>
EmptyLineBeforeAccessModifier(EmptyLineBeforeAccessModifierStyle) <font color=green>12以降</font>
</dt><dd>
アクセス修飾子の前に対する制御方法を指定する。

| 値             | 意味 |
|:---------------|:-----|
| Never          | アクセス修飾子の前の空行をすべて削除する。 |
| Leave          | アクセス修飾子の前の空行を削除しない。 |
| LogicalBlock   | アクセス修飾子が新しい論理ブロックを開始する場合だけ、空行を追加する。論理ブロックとは1つ以上のフィールド又は関数からなるグループのことを指す。|
| Always         | アクセス修飾子がクラスや構造体の先頭にある場合を除き、アクセス修飾子の前に空行を追加する。|

<dl><dd>

```C++:Never
struct foo {
private:
  int i;
protected:
  int j;
  /* comment */
public:
  foo() {}
private:
protected:
};
```
```C++:LogicalBlock
struct foo {
private:
  int i;

protected:
  int j;
  /* comment */
public:
  foo() {}

private:
protected:
};
```
```C++:Always
struct foo {
private:
  int i;

protected:
  int j;
  /* comment */

public:
  foo() {}

private:

protected:
};
```
</dd></dl>
</dd></dl>
<!-- ***************  EmptyLineBeforeAccessModifier END  *************** -->

<!-- ***************  ExperimentalAutoDetectBinPacking START  *************** -->
<dl><dt>
ExperimentalAutoDetectBinPacking(Boolean) <font color=green>3.7以降</font>
</dt><dd>
trueの場合、clang-formatは関数呼び出しと定義が1行に1つのパラメータでフォーマットされているかどうかを検出します。<br/>
<br/>
各呼び出しはbin-packed、1行ごと、または決定的でないことができます。もし結論が出ない場合、例えば完全に一行で、しかし決定を下す必要がある場合、clang-formatは入力ファイルに他のbin-packedケースがあるかどうかを分析し、それに応じて行動します。<br/>

:::note warn
**注意**
これは実験的なフラグであり、削除されたり名前が変更されたりする可能性があります。設定ファイルなどでは使用しないでください。ご自身の責任で使用してください。
:::

:::note info
**メモ書き**
記述内容及び挙動が理解できなかった為、直訳のみ。
:::

</dd></dl>
<!-- ***************  ExperimentalAutoDetectBinPacking END  *************** -->

<!-- ***************  FixNamespaceComments START  *************** -->
<dl><dt>
FixNamespaceComments(Boolean) <font color=green>5以降</font>
</dt><dd>
名前空間の終了に自動でコメントを挿入するかを指定する。<br/>
<dl><dd>

```C++:true
namespace a {
foo();
bar();
} // namespace a
// ↑上記のコメントが自動で挿入される。
```
```C++:false
namespace a {
foo();
bar();
}
// コメントの挿入が行われない。
```
</dd></dl>

:::note info
**メモ書き**
falseを指定しても既存のコメントが削除となるわけではない。逆にtrueを指定した場合、既存で独自にコメントを記載していても自動挿入で上書きされてしまう。
:::

</dd></dl>
<!-- ***************  FixNamespaceComments END  *************** -->

<!-- ***************  ForEachMacros START  *************** -->
<dl><dt>
ForEachMacros(List of Strings) <font color=green>3.7以降</font>
</dt><dd>
foreachとして解釈されるべきマクロ名のリストを指定する。<br/>
<dl><dd>

```c++:例
// FOREACHマクロがforeachとして動作する
FOREACH(<variable-declaration>, ...)
  <loop-body>
```
</dd></dl>
.clang-format 設定ファイルでは、次の様に設定することができる。
<dl><dd>

```yaml:
ForEachMacros: ['RANGES_FOR', 'FOREACH', 'BOOST_FOREACH']
```
</dd></dl>
</dd></dl>
<!-- ***************  ForEachMacros END  *************** -->

<!-- ***************  IfMacros START  *************** -->
<dl><dt>
IfMacros(List of Strings) <font color=green>13以降</font>
</dt><dd>
ifとして解釈されるべきマクロ名のリストを指定する。<br/>
<dl><dd>

```c++:例
IF(...)
  <conditional-body>
else IF(...)
  <conditional-body>
```
</dd></dl>
.clang-format 設定ファイルでは、次の様に設定することができる。
<dl><dd>

```yaml:
ForEachMacros: ['IF', 'KJ_IF_MAYBE']
```
</dd></dl>
</dd></dl>
<!-- ***************  IfMacros END  *************** -->

<!-- ***************  IncludeBlocks START  *************** -->
<dl><dt>
IncludeBlocks(IncludeBlocksStyle) <font color=green>6以降</font>
</dt><dd>
#include定義の並び順を決定する。 

| 値             | 意味 |
|:---------------|:-----|
| Preserve       | ブロック単位でソートを行う。 |
| Merge          | ブロックを結合し、ソートを行う。 |
| Regroup        | ブロックを結合し、ソートを行う。その後、カテゴリの優先順位に基づいてグループを分割する。IncludeCategoriesを参照。 |

<dl><dd>

```C++:参考：ソート前
#include "b.h"

#include <lib/main.h>
#include "a.h" 
```
```C++:Preserve
#include "b.h"

#include "a.h" 
#include <lib/main.h>
```
```C++:Merge
#include "a.h" 
#include "b.h"
#include <lib/main.h>
```
```C++:Regroup
#include "a.h" 
#include "b.h"

#include <lib/main.h>
```
</dd></dl>
</dd></dl>
<!-- ***************  IncludeBlocks END  *************** -->

<!-- ***************  IncludeCategories START  *************** -->
<dl><dt>
IncludeBlocks(List of IncludeCategories) <font color=green>3.8以降</font>
</dt><dd>
インクルードの順序付けに使用される、さまざまな #include カテゴリを示す正規表現です。<br/>
正規表現の表記はPOSIXに準拠する。<br/>
これらの正規表現は、インクルードのファイル名(<>または""を含む)の順に照合されます。最初にマッチした正規表現に属する優先順位が割り当てられ、#includeは、優先順位及びカテゴリ内でアルファベット順にソートされます。<br/>
<br/>
どの正規表現にも一致しない場合、INT_MAXがカテゴリーとして割り当てられます。ソースファイルのメインヘッダは自動的にカテゴリ0になります。そのため、一般的には#includesの先頭に置かれます。しかし、常に最初に来る必要があるヘッダーがある場合は、負の優先順位を割り当てることもできます。<br/>
<br/>
3番目のオプションフィールドにSortPriorityがあります。これは、IncludeBlocksにRegroupを指定した場合、有効となり、#includesを並べる優先順位を定義することができます。Priorityの値は、#includeブロックの順序を定義し、また、異なる優先順位の#includeをグループ化することができます。SortPriorityが指定されていない場合、Priorityの値がデフォルトとして設定されます。<br/>
<br/>
各正規表現は、CaseSensitiveフィールドで大文字と小文字を区別するようにマークすることができますが、デフォルトではそうではありません。<br/>

.clang-format ファイルで設定するには、次のようにします。

<dl><dd>

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

:::note info
**メモ書き**
SortPriority及びCaseSensitiveについては、古いバージョンでは指定ができない。(少なくとも8.0.1では使用ができなかった。)。いつ段階から実装されたかについては未調査。
:::

</dd></dl>
<!-- ***************  IncludeCategories END  *************** -->

<!-- ***************  IncludeIsMainRegex START  *************** -->
<dl><dt>
IncludeIsMainRegex(String) <font color=green>3.9以降</font>
</dt><dd>
file-to-main-include のマッピングで許可されるサフィックスの正規表現を指定します。<br/>
ある#includeが「メイン」includeであるかどうかを推測する場合（カテゴリ0を割り当てるため、上記を参照）、ヘッダーステムに許容される接尾辞のこの正規表現を使用します。部分マッチが行われ、次のようになります。- "" は "任意のサフィックス" を意味します - "$" は "サフィックスなし" を意味します。<br/>
<br/>
例えば、"(_test)?$" と設定した場合、ヘッダ a.h は a.cc と a_test.cc の両方で "main" include とみなされるでしょう。<br/>

:::note info
**メモ書き**
記述内容が明確に理解できなかった為、直訳。
以下、見解。
IncludeCategoriesの動作でソースファイルに対応するメインヘッダを判定するための正規表現を指定する。つまり、"(_test)?$"という正規表現を指定した場合、a.ccというソースファイルのヘッダファイルはa.hと判断し、インクルードの記述をソートする際に、(負の優先度を持つヘッダを除いて)一番先頭に配置される。
:::

</dd></dl>
<!-- ***************  IncludeIsMainRegex END  *************** -->

<!-- ***************  IncludeIsMainSourceRegex START  *************** -->
<dl><dt>
IncludeIsMainSourceRegex(String) <font color=green>10以降</font>
</dt><dd>
フォーマットされるファイルのうち、file-to-main-includeマッピングで "main "とみなすことが許されるファイルの正規表現を指定します。<br/>
<br/>
デフォルトでは、clang-formatはファイルが以下のように終わるときだけ "main "と見なします。.c, .cc, .cpp, .c++, .cxx, .m, .mm の拡張子で終わる場合のみ、clang-format はファイルを "main" と見なします。これらのファイルでは、「main」インクルードの推測が行われます（カテゴリ0を割り当てるには、上記を参照してください）。このオプションは、"main "とみなされるファイルのサフィックスと拡張子を追加することができます。<br/>
<br/>
例えば、このオプションを (Impl.hpp)$ に設定すると、ClassImpl.hpp が "main" と見なされ (Class.c, Class.cc, Class.cpp などに加えて)、"main include file" ロジックが実行されます (IncludeIsMainRegex 設定も後のフェーズで尊重される)。このオプションが設定されていないと、ClassImpl.hppは他のどのincludeよりも先にmain include fileをトップに置くことができません。<br/>

:::note info
**メモ書き**
記述内容が明確に理解できなかった為、直訳。
以下、見解。
IncludeIsMainRegexのソースファイル版。ソースファイルをインクルードした場合にメインとなるソースを判定する為の正規表現を指定する。
:::

</dd></dl>
<!-- ***************  IncludeIsMainSourceRegex END  *************** -->

<!-- ***************  IndentAccessModifiers START  *************** -->
<dl><dt>
IndentAccessModifiers(Boolean) <font color=green>13以降</font>
</dt><dd>
アクセス修飾子が独自のインデントレベルを持つかどうかを指定します。<br/>
trueの場合、アクセス修飾子は独自のインデント・レベルを取得します。その結果、アクセス修飾子の有無にかかわらず、レコードのメンバは常にレコードの下の2つのレベルにインデントされます。AccessModifierOffsetの値は無視されます。<br/>
false の場合、アクセス修飾子はAccessModifierOffsetに従ってレコード・メンバから相対的にインデント (またはアウトデント)されます。レコード・メンバーはレコードの1レベル下にインデントされます。<br/>
<dl><dd>

```C++:true
class C {
    class D {
        void bar();
      protected:
        D();
    };
  public:
    C();
};
void foo() {
  return 1;
}
```
```C++:false
class C {
  class D {
    void bar();
  protected:
    D();
  };
public:
  C();
};
void foo() {
  return 1;
}
```
</dd></dl>


</dd></dl>
<!-- ***************  IndentAccessModifiers END  *************** -->

<!-- ***************  IndentCaseBlocks START  *************** -->
<dl><dt>
IndentCaseBlocks(Boolean) <font color=green>11以降</font>
</dt><dd>
ケースラベルブロックをケースラベルから1レベルインデントします。<br/>
trueの場合、ブロックはスコープブロックとしてインデントされます。<br/>
false の場合、ケースラベルに続くブロックはケースラベルと同じインデントレベルを使用し、ケースラベルは if 文と同じように扱われます。<br/>

<dl><dd>

```C++:true
switch (fool) {
case 1:
  {
    bar();
  }
  break;
default:
  {
    plop();
  }
}
```
```C++:false
switch (fool) {
case 1: {
  bar();
} break;
default: {
  plop();
}
}
```
</dd></dl>

</dd></dl>
<!-- ***************  IndentCaseBlocks END  *************** -->

<!-- ***************  IndentCaseLabels START  *************** -->
<dl><dt>
IndentCaseLabels(Boolean) <font color=green>3.3以降</font>
</dt><dd>
switch文のケースラベルのインデントを指定する。<br/>
trueの場合、ケースラベルはswitch文よりも一段インデントされます。<br/>
falseの場合、ケースラベルはswitch文と同じインデントレベルを使用します。<br/>
ステートメント本体は常にケースラベルよりも一段インデントされます。<br/>
<dl><dd>

```C++:true
switch (fool) {
  case 1:
    bar();
    break;
  default:
    plop();
}
```
```C++:false
switch (fool) {
case 1:
  bar();
  break;
default:
  plop();
}
```
</dd></dl>

</dd></dl>
<!-- ***************  IndentCaseLabels END  *************** -->

<!-- ***************  IndentExternBlock START  *************** -->
<dl><dt>
IndentExternBlock(IndentExternBlockStyle) <font color=green>11以降</font>
</dt><dd>
外部結合ブロックのインデントの種類を指定する。

| 値               | 意味 |
|:-----------------|:-----|
| AfterExternBlock | BraceWrapping.AfterExternBlockの動作に従う。(AfterExternBlockの項を参照) |
| NoIndent         | 外部結合ブロックのインデントを行わない。 |
| Indent           | 外部結合ブロックのインデントを行う。 |
| true             | Indentと同じ動作となる。(レガシーオプション) |
| false            | NoIndentと同じ動作となる。(レガシーオプション) |

<dl><dd>

```C++:NoIndent
extern "C" {
void foo();
}
```
```C++:Indent
extern "C" {
  void foo();
}
```
</dd></dl>
</dd></dl>
<!-- ***************  IndentExternBlock END  *************** -->

<!-- ***************  IndentGotoLabels START  *************** -->
<dl><dt>
IndentGotoLabels(Boolean) <font color=green>10以降</font>
</dt><dd>
gotoラベルのインデントを指定する。<br/>
<dl><dd>

```C++:true
// gotoラベルはステートメント内で左寄せになる
int f() {
  if (foo()) {
  label1:
    bar();
  }
label2:
  return 1;
}
```
```C++:false
// gotoラベルは左寄せになる
int f() {
  if (foo()) {
label1:
    bar();
  }
label2:
  return 1;
}
```
</dd></dl>

</dd></dl>
<!-- ***************  IndentGotoLabels END  *************** -->

<!-- ***************  IndentPPDirectives START  *************** -->
<dl><dt>
IndentPPDirectives(IndentExternBlockStyle) <font color=green>6以降</font>
</dt><dd>
プリプロセッサ・ディレクティブのインデントの種類を指定する。

| 値             | 意味 |
|:---------------|:-----|
| None           | プリプロセッサ・ディレクティブのインデントを行わない。 |
| AfterHash      | ハッシュの後についてインデントを行う。 |
| BeforeHash     | ハッシュを含めてインデントを行う。 |

<dl><dd>

```C++:None
#if FOO
#if BAR
#include <foo>
#endif
#endif
```
```C++:AfterHash
#if FOO
#  if BAR
#    include <foo>
#  endif
#endif
```
```C++:BeforeHash
#if FOO
  #if BAR
    #include <foo>
  #endif
#endif
```
</dd></dl>
</dd></dl>
<!-- ***************  IndentPPDirectives END  *************** -->

<!-- ***************  IndentRequiresClause START  *************** -->
<dl><dt>
IndentRequiresClause(Boolean) <font color=green>15以降</font>
</dt><dd>
テンプレート定義のrequires節のインデントを指定する。<br/>
これは、RequiresClausePositionがOwnLine又はWithFollowingの場合にのみ適用されます。<br/>

:::note info
備考
名前が変更されています。clang-format 12～14では、IndentRequiresという名前でした。
:::

<dl><dd>

```C++:true
template <typename It>
  requires Iterator<It>
void sort(It begin, It end) {
  //....
}
```
```C++:false
template <typename It>
requires Iterator<It>
void sort(It begin, It end) {
  //....
}
```
</dd></dl>
</dd></dl>
<!-- ***************  IndentRequiresClause END  *************** -->

<!-- ***************  IndentWidth START  *************** -->
<dl><dt>
IndentWidth(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
インデントに使用する値を指定する<br/>
</dd></dl>
<!-- ***************  IndentWidth END  *************** -->

<!-- ***************  IndentWrappedFunctionNames START  *************** -->
<dl><dt>
IndentWrappedFunctionNames(Boolean) <font color=green>3.7以降</font>
</dt><dd>
関数定義や宣言が1行に収まらない場合、次行をインデントするか指定する。<br/>
<dl><dd>

```C++:true
// 次の行をインデントする
LoooooooooooooooooooooooooooooooooooooooongReturnType
    LoooooooooooooooooooooooooooooooongFunctionDeclaration();
```
```C++:false
// 次の行をインデントしない
LoooooooooooooooooooooooooooooooooooooooongReturnType
    LoooooooooooooooooooooooooooooooongFunctionDeclaration();
```
</dd></dl>
</dd></dl>
<!-- ***************  IndentWrappedFunctionNames END  *************** -->

<!-- ***************  InsertBraces START  *************** -->
<dl><dt>
InsertBraces(Boolean) <font color=green>15以降</font>
</dt><dd>
C++の制御文（if, else, for, do, while）の後に波括弧を入れる。ただし、制御文がマクロ定義の中にあるか、波括弧がプリプロセッサー指令を囲んでしまう場合は除く。<br/>

:::note warn
警告
このオプションを true に設定すると、clang-format の完全なセマンティック情報の欠如により、不正なコードフォーマットになる可能性があります。そのため、このオプションで変更されたコードをレビューする際には、特に注意が必要です。
:::
<dl><dd>

```C++:true
// 波括弧を省略しているステートメントについて自動で波括弧を付与する
if (isa<FunctionDecl>(D)) {
  handleFunctionDecl(D);
} else if (isa<VarDecl>(D)) {
  handleVarDecl(D);
} else {
  return;
}

while (i--) {
  for (auto *A : D.attrs()) {
    handleAttr(A);
  }
}
do {
  --i;
} while (i);
```
```C++:false
// 波括弧を省略しているステートメントについて何もしない
if (isa<FunctionDecl>(D))
  handleFunctionDecl(D);
else if (isa<VarDecl>(D))
  handleVarDecl(D);
else
  return;

while (i--)
  for (auto *A : D.attrs())
    handleAttr(A);
do
  --i;
while (i);
```
</dd></dl>

:::note info
**メモ書き**
既に波括弧を付与しているファイルに対してfalseを指定しても、波括弧の削除は行われない。
:::

</dd></dl>
<!-- ***************  InsertBraces END  *************** -->

<!-- ***************  InsertTrailingCommas START  *************** -->
<dl><dt>
InsertTrailingCommas(TrailingCommaStyle) <font color=green>11以降</font>
</dt><dd>
複数行にまたがるコンテナリテラル(配列とオブジェクト)の末尾のカンマを付与を指定する。<br/>
Clang-Format15の段階ではJavaScriptのみ使用可能で、デフォルトはNoneで無効となっている。<br/>
また、BinPackArgumentsと同時に使用することは出来ません。

| 値             | 意味 |
|:---------------|:-----|
| None           | 末尾にカンマを挿入しない。 |
| Wrapped        | 末尾にカンマを挿入する。 |

<dl><dd>

```JavaScript:Wrapped
const someArray = [
aaaaaaaaaaaaaaaaaaaaaaaaaa,
aaaaaaaaaaaaaaaaaaaaaaaaaa,
aaaaaaaaaaaaaaaaaaaaaaaaaa,
//                        ^ inserted
]
```
</dd></dl>
</dd></dl>
<!-- ***************  InsertTrailingCommas END  *************** -->

<!-- ***************  JavaImportGroups START  *************** -->
<dl><dt>
InsertTrailingCommas(List of Strings) <font color=green>8以降</font>
</dt><dd>
Javaのimport宣言のグループ化の接頭辞を指定する。<br/>
一致する接頭辞が複数ある場合、最長の接頭辞を優先する。グループ内は辞書順にソートされる。静的なインポートは別でグループ化され、同じルールが適用となる。デフォルトでは静的なインポート宣言は非静的なインポート宣言の前に配置される。この動作はSortJavaStaticImportにより変更が可能である。<br/>

.clang-format ファイルで次の設定をした場合、Javaのインポート宣言は以下のように並びます。

<dl><dd>

```yaml:
JavaImportGroups: ['com.example', 'com', 'org']
```
```Java:Javaソースの例
import static com.example.function1;

import static com.test.function2;

import static org.example.function3;

import com.example.ClassA;
import com.example.Test;
import com.example.a.ClassB;

import com.test.ClassC;

import org.example.ClassD;
```
</dd></dl>
</dd></dl>
<!-- ***************  InsertTrailingCommas END  *************** -->

<!-- ***************  JavaScriptQuotes START  *************** -->
<dl><dt>
JavaScriptQuotes(JavaScriptQuoteStyle) <font color=green>3.9以降</font>
</dt><dd>
JavaScriptの文字列のクォートを指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Leave          | 文字列のクォートは変更しない。 |
| Single         | 常にシングルクォートを使用する。 |
| Double         | 常にダブルクォートを使用する。 |

<dl><dd>

```JavaScript:Leave
string1 = "foo";
string2 = 'bar';
```
```JavaScript:Single
string1 = 'foo';
string2 = 'bar';
```
```JavaScript:Single
string1 = "foo";
string2 = "bar";
```
</dd></dl>
</dd></dl>
<!-- ***************  JavaScriptQuotes END  *************** -->

<!-- ***************  JavaScriptWrapImports START  *************** -->
<dl><dt>
JavaScriptWrapImports(Boolean) <font color=green>3.9以降</font>
</dt><dd>
JavaScriptのimport/export文をラップ方法を指定する。<br/>

<dl><dd>

```JavaScript:true
import {
    VeryLongImportsAreAnnoying,
    VeryLongImportsAreAnnoying,
    VeryLongImportsAreAnnoying,
} from 'some/module.js'
```
```JavaScript:false
import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
```
</dd></dl>
</dd></dl>
<!-- ***************  JavaScriptWrapImports END  *************** -->

<!-- ***************  KeepEmptyLinesAtTheStartOfBlocks START  *************** -->
<dl><dt>
KeepEmptyLinesAtTheStartOfBlocks(Boolean) <font color=green>3.7以降</font>
</dt><dd>
ブロックの先頭の空白の扱いを指定する。<br/>
<dl><dd>

```C++:true
// ブロックの先頭の空白を維持する
if (foo) {

  bar();
}
```
```C++:false
// ブロックの先頭の空白を削除する
if (foo) {
  bar();
}
```
</dd></dl>

:::note info
**メモ書き**
維持であり、挿入ではない。trueを指定しても空白行の挿入は行われない。
:::

</dd></dl>
<!-- ***************  KeepEmptyLinesAtTheStartOfBlocks END  *************** -->

<!-- ***************  LambdaBodyIndentation START  *************** -->
<dl><dt>
LambdaBodyIndentation(LambdaBodyIndentationKind) <font color=green>13以降</font>
</dt><dd>
ラムダ式の本体の改行ルールを指定する。<br/>
コールバックの多いコードではOuterScopeを使用してシグネチャを2段階インデントした方が可読性が高くなる場合がある。(<a href=https://github.com/capnproto/capnproto/blob/master/style-guide.md>KJ Style guide</a>ではOuterScopeを必須としています)

| 値             | 意味 |
|:---------------|:-----|
| Signature      | ラムダ式の本体をシグネチャのインデントレベルに対して1段下げる。 |
| OuterScope     | ラムダ式の本体を親スコープのインデントレベルに対して1段下げる。 |

<dl><dd>

```C++:Signature
someMethod(
    [](SomeReallyLongLambdaSignatureArgument foo) {
      return;
    });
```
```C++:OuterScope
someMethod(
    [](SomeReallyLongLambdaSignatureArgument foo) {
  return;
});
```
</dd></dl>
</dd></dl>
<!-- ***************  LambdaBodyIndentation END  *************** -->

<!-- ***************  Language START  *************** -->
<dl><dt>
Language(LanguageKind) <font color=green>3.5以降</font>
</dt><dd>
対象となる言語を指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Cpp            | C言語及びC++に使用する。 |
| CSharp         | C♯に使用する。 |
| Java           | Javaに使用する。 |
| JavaScript     | JavaScriptに使用する。 |
| Json           | Jsonに使用する。 |
| ObjC           | Objective-C及びObjective-C++に使用する。 |
| Proto          | Protocol Buffersに使用する。(https://developers.google.com/protocol-buffers/) |
| TableGen       | TableGenに使用する。 |
| TextProto      | テキスト形式のProtocol Buffersに使用する。(https://developers.google.com/protocol-buffers/) |
| Verilog        | Verilog及びSystemVerilogに使用する。(https://standards.ieee.org/ieee/1800/6700/ https://sci-hub.st/10.1109/IEEESTD.2018.8299595) |

:::note info
**メモ書き**
公式にはNoneが使用不可で記載されている。プログラム上、LanguageKindにNoneの定義が無いので指定するとyamlの解析でエラーになる。(使用不可というかそもそも使えない、レガシー？)
:::

<dl><dd>

```yaml:例
---
# 各言語の共通設定を記述する
BasedOnStyle: LLVM
IndentWidth: 4
---
# C++固有の設定を書く
Language: Cpp
...
# ここまでC++固有の設定
---
# JavaScript固有の設定を書く
Language: JavaScript
...
# ここまでJavaScript固有の設定
---
# 以下同様に必要な言語の設定を記載していく
...
```
</dd></dl>

</dd></dl>
<!-- ***************  Language END  *************** -->

<!-- ***************  MacroBlockBegin、MacroBlockEnd START  *************** -->
<dl><dt>
MacroBlockBegin(String) <font color=green>3.7以降</font><br/>
MacroBlockEnd(String) <font color=green>3.7以降</font>
</dt><dd>
ブロックの先頭及び末尾となるマクロを正規表現で指定する。<br/>
<dl><dd>

```yaml:記述例
MacroBlockBegin: "^NS_MAP_BEGIN|NS_TABLE_HEAD$"
MacroBlockEnd: "^NS_MAP_END|NS_TABLE_.*_END$"
```

```C++:実行例(MacroBlockBegin及びMacroBlockEndを指定しない場合)
// マクロで開始終了を内包するようなパターンの場合
#deinfe NS_MAP_BEGIN if( x ) {
#deinfe NS_MAP_END   }

// 開始/終了のマクロが判断できないため、本体部分の処理が前寄せになる。
NS_MAP_BEGIN
foo();
NS_MAP_END
```
```C++:実行例(MacroBlockBegin及びMacroBlockEndを指定した場合)
// 開始/終了のマクロが正規表現で判定出来たため、本体部分の処理にインデントが付与される。
NS_MAP_BEGIN
  foo();
NS_MAP_END
```

</dd></dl>
</dd></dl>
<!-- ***************  MacroBlockBegin、MacroBlockEnd  END  *************** -->

<!-- ***************  MaxEmptyLinesToKeep START  *************** -->
<dl><dt>
MaxEmptyLinesToKeep(String) <font color=green>3.7以降</font><br/>
</dt><dd>
空行の最大保持数を指定する。<br/>
<dl><dd>

```C++:変更前
int f() {


  int i = 1;


  i = foo();


  return i;


}
```
```C++:MaxEmptyLinesToKeep : 0 を指定した場合
int f() {
  int i = 1;
  i = foo();
  return i;
}
```
```C++:MaxEmptyLinesToKeep : 1 を指定した場合
int f() {

  int i = 1;

  i = foo();

  return i;
}
// ↑ステートメントの終了前の空白は必ずすべて削除される。
```

</dd></dl>

:::note info
**メモ書き**
MaxEmptyLinesToKeepにNを指定しても最大N行の空白行が残るだけで、N行の空白が挿入となるわけではない。 
:::

</dd></dl>
<!-- ***************  MaxEmptyLinesToKeep END  *************** -->

<!-- ***************  NamespaceIndentation START  *************** -->
<dl><dt>
NamespaceIndentation(NamespaceIndentationKind) <font color=green>3.7以降</font>
</dt><dd>
名前空間のインデントを指定する。<br/>
コールバックの多いコードではOuterScopeを使用してシグネチャを2段階インデントした方が可読性が高くなる場合がある。(<a href=https://github.com/capnproto/capnproto/blob/master/style-guide.md>KJ Style guide</a>ではOuterScopeを必須としています)

| 値             | 意味 |
|:---------------|:-----|
| None           | 名前空間にインデントを行わない。 |
| Inner          | ネストした名前空間だけインデントを行う。 |
| All            | すべての名前空間をインデントする。 |

<dl><dd>

```C++:None
namespace out {
int i;
namespace in {
int i;
}
}
```
```C++:Inner
namespace out {
int i;
namespace in {
  int i;
}
}
```
```C++:All
namespace out {
  int i;
  namespace in {
    int i;
  }
}
```
</dd></dl>
</dd></dl>
<!-- ***************  NamespaceIndentationKind END  *************** -->

<!-- ***************  NamespaceMacros START  *************** -->
<dl><dt>
NamespaceMacros(List of Strings) <font color=green>9以降</font><br/>
</dt><dd>
名前空間の開始となるマクロのリストを指定する。<br/>
<dl><dd>

```yaml:記述例
NamespaceMacros: ['NAMESPACE', 'TESTSUITE']
```
```C++:実行例
NAMESPACE(<namespace-name>, ...) {
  <namespace-content>
}
```
</dd></dl>
</dd></dl>
<!-- ***************  NamespaceMacros END  *************** -->

<!-- ***************  ObjCBinPackProtocolList START  *************** -->
<dl><dt>
ObjCBinPackProtocolList(BinPackStyle) <font color=green>9以降</font>
</dt><dd>
Objective-Cプロトコル準拠のリスト項目がColumnLimitを超えた場合の改行の制御を指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Auto| BinPackParametersの指定に従う。BinPackParametersがtrueの場合、Alwaysと同じ動作となる。falseの場合、Neverと同じ動作となる。 |
| Always| ColumnLimitに収まる最小の行に纏める。 |
| Never| 個々の行に纏める。 |

<dl><dd>

```Objective-C:Always(又はAutoかつBinPackParametersがtrue)
@interface ccccccccccccc () <
    ccccccccccccc, ccccccccccccc,
    ccccccccccccc, ccccccccccccc> {
}
```
```Objective-C:Never(又はAutoかつBinPackParametersがfalse)
@interface ddddddddddddd () <
    ddddddddddddd,
    ddddddddddddd,
    ddddddddddddd,
    ddddddddddddd> {
}
```
</dd></dl>
</dd></dl>
<!-- ***************  ObjCBinPackProtocolList END  *************** -->

<!-- ***************  ObjCBlockIndentWidth START  *************** -->
<dl><dt>
ObjCBlockIndentWidth(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
Objective-Cブロックのインデントの値を指定する。<br/>

</dd></dl>
<!-- ***************  ObjCBlockIndentWidth END  *************** -->

<!-- ***************  ObjCBreakBeforeNestedBlockParam START  *************** -->
<dl><dt>
ObjCBreakBeforeNestedBlockParam(Boolean) <font color=green>11以降</font>
</dt><dd>
Objective-Cの関数呼び出し時にブロックパラメータがネストしている場合の、パラメータリストの記載方法について指定する。<br/>

<dl><dd>

```Objective-C:true
- (void)_aMethod
{
  [self.test1 t:self
              w:self
       callback:^(typeof(self) self, NSNumber *u, NSNumber *v) {
           u = c;
       }]
}
```
```Objective-C:false
- (void)_aMethod
{
  [self.test1 t:self w:self
       callback:^(typeof(self) self, NSNumber *u, NSNumber *v) {
           u = c;
       }]
}
```
</dd></dl>
</dd></dl>
<!-- ***************  JavaScriptWrapImports END  *************** -->

<!-- ***************  ObjCSpaceAfterProperty START  *************** -->
<dl><dt>
ObjCSpaceAfterProperty(Boolean) <font color=green>3.7以降</font>
</dt><dd>
Objective-Cの<span>@</span>propertyの後にスペースを入れるかを指定する。<br/>

<dl><dd>

```Objective-C:true
@property (readonly) NSString* foo; 
```
```Objective-C:false
@property(readonly) NSString* foo; 
```
</dd></dl>
</dd></dl>
<!-- ***************  ObjCSpaceAfterProperty END  *************** -->

<!-- ***************  ObjCSpaceBeforeProtocolList START  *************** -->
<dl><dt>
ObjCSpaceBeforeProtocolList(Boolean) <font color=green>3.7以降</font>
</dt><dd>
Objective-Cのプロトコルリストの前にスペースを入れるかを指定する。<br/>

<dl><dd>

```Objective-C:true
@protocol Foo <NSObject>
```
```Objective-C:false
@protocol Foo<NSObject>
```
</dd></dl>
</dd></dl>
<!-- ***************  ObjCSpaceBeforeProtocolList END  *************** -->

<!-- ***************  PPIndentWidth START  *************** -->
<dl><dt>
PPIndentWidth(Integer) <font color=green>13以降</font>
</dt><dd>
プリプロセッサのインデントの値を指定する。<br/>
-1を指定した場合、IndentWidthの値が使用される。

<dl><dd>

```C++:PPIndentWidth: 1 の場合
#ifdef __linux__
# define FOO
#else
# define BAR
#endif
```
</dd></dl>
</dd></dl>
<!-- ***************  PPIndentWidth END  *************** -->

<!-- ***************  PackConstructorInitializers START  *************** -->
<dl><dt>
PackConstructorInitializers(PackConstructorInitializersStyle) <font color=green>14以降</font>
</dt><dd>
コンストラクタの初期化リストの並べ方について指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Never          | 初期化リストは1行ずつ改行する。 |
| BinPack        | ColumnLimitに収まる最小の行に纏める。 |
| CurrentLine    | すべての初期化リストが1行に収まる場合、1行に纏める。1行に収まらない場合、Neverと同じ動作となる。 |
| NextLine       | CurrentLineと同じ動作。ただし、コンストラクタの開始行にすべての要素が収まらない場合、次の行に収まるようにする。 |

<dl><dd>

```C++:Never
Constructor()
    : a(),
      b()
```
```C++:BinPack
Constructor()
    : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(),
      cccccccccccccccccccc()
```
```C++:CurrentLine
Constructor() : a(), b()

// すべての要素が1行で収まらない場合、Neverと同じ動作をする
Constructor()
    : aaaaaaaaaaaaaaaaaaaa(),
      bbbbbbbbbbbbbbbbbbbb(),
      ddddddddddddd()
```
```C++:NextLine
// コンストラクタと同じ行に収まる場合、その行にすべての要素を出力する。
Constructor() : a(), b()

// コンストラクタと同じ行に収まらない場合、次の行に収まるように整形する。
Constructor()
    : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd()

// 次の行にも収まらない長さの場合、Neverと同じ動作をする。
Constructor()
    : aaaaaaaaaaaaaaaaaaaa(),
      bbbbbbbbbbbbbbbbbbbb(),
      cccccccccccccccccccc()
```
</dd></dl>
</dd></dl>
<!-- ***************  PackConstructorInitializers END  *************** -->

<!-- ***************  PenaltyBreakAssignment START  *************** -->
<dl><dt>
PenaltyBreakAssignment(Unsigned) <font color=green>5以降</font>
</dt><dd>
代入演算子関連の改行に対するペナルティ<br/>

:::note alert
**メモ書き**
以降Penalty～について、用途が理解できなかった為、直訳のみ。
ただし、BasedOnStyleの各定義を見ると値を設定しているため、必要な数値である模様。
:::

</dd></dl>
<!-- ***************  PenaltyBreakAssignment END  *************** -->

<!-- ***************  PenaltyBreakBeforeFirstCallParameter START  *************** -->
<dl><dt>
PenaltyBreakBeforeFirstCallParameter(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
関数呼び出し後の改行に対するペナルティ<br/>
</dd></dl>
<!-- ***************  PenaltyBreakBeforeFirstCallParameter END  *************** -->

<!-- ***************  PenaltyBreakComment START  *************** -->
<dl><dt>
PenaltyBreakComment(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
コメント内での改行に対するペナルティ<br/>
</dd></dl>
<!-- ***************  PenaltyBreakComment END  *************** -->

<!-- ***************  PenaltyBreakFirstLessLess START  *************** -->
<dl><dt>
PenaltyBreakFirstLessLess(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
最初の左シフトの前の改行に対するペナルティ<br/>
</dd></dl>
<!-- ***************  PenaltyBreakFirstLessLess END  *************** -->

<!-- ***************  PenaltyBreakOpenParenthesis START  *************** -->
<dl><dt>
PenaltyBreakOpenParenthesis(Unsigned) <font color=green>14以降</font>
</dt><dd>
’(’の後の改行に対するペナルティ<br/>
</dd></dl>
<!-- ***************  PenaltyBreakOpenParenthesis END  *************** -->

<!-- ***************  PenaltyBreakString START  *************** -->
<dl><dt>
PenaltyBreakString(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
文字列リテラル内の改行に対するペナルティ<br/>
</dd></dl>
<!-- ***************  PenaltyBreakString END  *************** -->

<!-- ***************  PenaltyBreakTemplateDeclaration START  *************** -->
<dl><dt>
PenaltyBreakTemplateDeclaration(Unsigned) <font color=green>7以降</font>
</dt><dd>
テンプレート宣言の後の改行に対するペナルティ<br/>
</dd></dl>
<!-- ***************  PenaltyBreakTemplateDeclaration END  *************** -->

<!-- ***************  PenaltyExcessCharacter START  *************** -->
<dl><dt>
PenaltyExcessCharacter(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
行の最大文字数を超過した場合の文字の改行に対するペナルティ<br/>
</dd></dl>
<!-- ***************  PenaltyExcessCharacter END  *************** -->

<!-- ***************  PenaltyIndentedWhitespace START  *************** -->
<dl><dt>
PenaltyIndentedWhitespace(Unsigned) <font color=green>12以降</font>
</dt><dd>
空白文字のインデント1文字あたりのペナルティ(非ホワイトスペースの先頭列からの相対値でカウントされる)。<br/>
</dd></dl>
<!-- ***************  PenaltyIndentedWhitespace END  *************** -->

<!-- ***************  PenaltyReturnTypeOnItsOwnLine START  *************** -->
<dl><dt>
PenaltyReturnTypeOnItsOwnLine(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
関数の戻り値の型を関数と同一行とした場合のペナルティ。<br/>
</dd></dl>
<!-- ***************  PenaltyReturnTypeOnItsOwnLine END  *************** -->

<!-- ***************  PointerAlignment START  *************** -->
<dl><dt>
PointerAlignment(PointerAlignmentStyle) <font color=green>3.7以降</font>
</dt><dd>
ポインタ及び参照のアライメントについて指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Left           | 左に寄せる。 |
| Right          | 右に寄せる。 |
| Middle         | 中央に寄せる。 |
| true           | Leftと同じ動作。(レガシーオプション) |
| false          | Rightと同じ動作。(レガシーオプション) |

<dl><dd>

```C++:Left
int* a;
```
```C++:Right
int *a;
```
```C++:Middle
int * a;
```
</dd></dl>
</dd></dl>
<!-- ***************  PointerAlignment END  *************** -->

<!-- ***************  QualifierAlignment START  *************** -->
<dl><dt>
QualifierAlignment(QualifierAlignmentStyle) <font color=green>14以降</font>
</dt><dd>
指定子や修飾子の並べ方を指定する(例：const/volatile)。<br/>

:::note warn
**警告**
QualifierAlignmentをLeave以外に設定すると、clang-formatsが完全な意味情報を持っていないため、間違った判断を下してしまい、コードが正しくフォーマットされない可能性があります。そのため、このオプションを使って変更されたコードをレビューする際には、特別な注意を払う必要があります。
:::

| 値             | 意味 |
|:---------------|:-----|
| Leave          | 変更しない。 |
| Left           | 指定子及び修飾子を左に寄せる。 |
| Right          | 指定子及び修飾子を右に寄せる。 |
| Custom         | QualifierOrderで指定した値に従う。 |

<dl><dd>

```C++:Leave
int const a;
const int *a;
```
```C++:Left
const int a;
const int *a;
```
```C++:Right
int const a;
int const *a;
```
```yaml:QualifierOrderの指定(Custom用)
QualifierOrder: ['inline', 'static' , 'type', 'const']
```
```C++:Custom
// 修飾子及び型がQualifierOrderで指定した順序('type', 'const')の順に並ぶ
int const a;
int const *a;
```
</dd></dl>
</dd></dl>
<!-- ***************  QualifierAlignment END  *************** -->

<!-- ***************  QualifierOrder START  *************** -->
<dl><dt>
QualifierOrder(List of Strings) <font color=green>14以降</font>
</dt><dd>
型、指定子及び修飾子の並び順を文字列リストで指定する。<br/>
この値はQualifierAlignmentにCustomを指定した場合、使用される。<br/>
指定する文字列リストは必ず'type'を含む必要がある。
指定可能なキーワードは以下のとおり。<br/>
・const<br/>
・inline<br/>
・static<br/>
・constexpr<br/>
・volatile<br/>
・restrict<br/>
・type<br/>
※typeはデータ型を意味する(例えばint)

<dl><dd>

```yaml:例
QualifierOrder: ['inline', 'static' , 'type', 'const']
```
</dd></dl>
</dd></dl>
<!-- ***************  QualifierOrder END  *************** -->

<!-- ***************  RawStringFormats START  *************** -->
<dl><dt>
RawStringFormats(List of RawStringFormats) <font color=green>6以降</font>
</dt><dd>
変換対象のファイルの内容がどの言語のコードブロックであるか判断するための定義を指定する。<br/>
デリミタが一致するか、関数名が一致する文字列を検出した場合、.clang-formatでその言語用に指定した定義によりフォーマットを行う。特定言語に対しての定義が見つからない場合、BasedOnStyleで指定したフォーマットに従い再変換を行う。BasedOnStyleが見つからない場合、llvmのフォーマットに基づき変換を行う。<br/>
マッチする言語は区切り文字にマッチするものが関数にマッチするものよりも優先されます。<br/>

<dl><dd>

```yaml:例
RawStringFormats:
  - Language: TextProto  # Language参照
      Delimiters: # 拡張子
        - 'pb'
        - 'proto'
      EnclosingFunctions: # 一致する関数等
        - 'PARSE_TEXT_PROTO'
      BasedOnStyle: google # 一致した場合のフォーマット
  - Language: Cpp
      Delimiters:
        - 'cc'
        - 'cpp'
      BasedOnStyle: llvm
      CanonicalDelimiter: 'cc'
```
</dd></dl>
</dd></dl>
<!-- ***************  RawStringFormats END  *************** -->

<!-- ***************  ReferenceAlignment START  *************** -->
<dl><dt>
ReferenceAlignment(ReferenceAlignmentStyle) <font color=green>13以降</font>
</dt><dd>
参照のアライメントについて指定する。(参照についてPointerAlignmentの指定を上書きする)<br/>

| 値             | 意味 |
|:---------------|:-----|
| Pointer        | PointerAlignmentの指定に従う。 |
| Left           | 左に寄せる。 |
| Right          | 右に寄せる。 |
| Middle         | 中央に寄せる。 |

<dl><dd>

```C++:Left
int& a;
```
```C++:Right
int &a;
```
```C++:Middle
int & a;
```
</dd></dl>
</dd></dl>
<!-- ***************  ReferenceAlignment END  *************** -->

<!-- ***************  ReflowComments START  *************** -->
<dl><dt>
ReflowComments(ReferenceAlignmentStyle) <font color=green>4以降</font>
</dt><dd>
1行の最大文字数を超えたコメントの折り返しについて指定する。<br/>

<dl><dd>

```C++:true
// ColumnLimitを超えるコメントを自動で改行する
// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
// information
/* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
 * information */
```
```C++:false
// ColumnLimitを超えるコメントの改行を行わない
// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
/* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
```
</dd></dl>
</dd></dl>
<!-- ***************  ReflowComments END  *************** -->

<!-- ***************  RemoveBracesLLVM START  *************** -->
<dl><dt>
RemoveBracesLLVM(Boolean) <font color=green>14以降</font>
</dt><dd>
LLVMコーディングスタイルに従って、C++の制御文（if, else, for, while）のオプションの波括弧を削除する。<br/>

:::note warn
**警告**
このオプションは名称を変更し、他のスタイルにも対応できるように拡張する予定です。
:::
:::note warn
**警告**
このオプションを true に設定すると、clang-format の完全なセマンティック情報の欠如により、不正なコードフォーマットになる可能性があります。そのため、このオプションで変更されたコードをレビューする際には、特に注意が必要です。
:::

<dl><dd>

```C++:true
// 省略が可能な波括弧について削除する
if (isa<FunctionDecl>(D))
  handleFunctionDecl(D);
else if (isa<VarDecl>(D))
  handleVarDecl(D);

if (isa<VarDecl>(D)) {
  for (auto *A : D.attrs())
    if (shouldProcessAttr(A))
      handleAttr(A);
}

if (isa<FunctionDecl>(D))
  for (auto *A : D.attrs())
    handleAttr(A);

if (auto *D = (T)(D)) {
  if (shouldProcess(D))
    handleVarDecl(D);
  else
    markAsIgnored(D);
}

if (a)
  b();
else if (c)
  d();
else
  e();
```
```C++:false
// 波括弧を特に変更しない
if (isa<FunctionDecl>(D)) {
  handleFunctionDecl(D);
} else if (isa<VarDecl>(D)) {
  handleVarDecl(D);
}

if (isa<VarDecl>(D)) {
  for (auto *A : D.attrs()) {
    if (shouldProcessAttr(A)) {
      handleAttr(A);
    }
  }
}

if (isa<FunctionDecl>(D)) {
  for (auto *A : D.attrs()) {
    handleAttr(A);
  }
}

if (auto *D = (T)(D)) {
  if (shouldProcess(D)) {
    handleVarDecl(D);
  } else {
    markAsIgnored(D);
  }
}

if (a) {
  b();
} else {
  if (c) {
    d();
  } else {
    e();
  }
}
```
</dd></dl>
</dd></dl>
<!-- ***************  RemoveBracesLLVM END  *************** -->

<!-- ***************  RequiresClausePosition START  *************** -->
<dl><dt>
RequiresClausePosition(RequiresClausePositionStyle) <font color=green>15以降</font>
</dt><dd>
requires句の改行について指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| OwnLine        | 必ず改行する。 |
| WithPreceding  | 宣言と同じ行となるようにする。クラス又は関数のテンプレート宣言の場合、テンプレート宣言に従う。関数宣言の場合、引数リストに従う。 |
| WithFollowing  | クラスや関数の宣言と同じにする。 |
| SingleLine     | 可能な限り1行に記載する。1行で記載できない場合、改行する。 |

<dl><dd>

```C++:OwnLine
template <typename T>
requires C<T>
struct Foo {...

template <typename T>
requires C<T>
void bar(T t) {...

template <typename T>
void baz(T t)
requires C<T>
{...
```
```C++:WithPreceding
template <typename T> requires C<T>
struct Foo {...

template <typename T> requires C<T>
void bar(T t) {...

template <typename T>
void baz(T t) requires C<T>
{...
```
```C++:WithFollowing
template <typename T>
requires C<T> struct Foo {...

template <typename T>
requires C<T> void bar(T t) {...

template <typename T>
void baz(T t)
requires C<T> {...
```
```C++:SingleLine
// 1行で収まる場合
template <typename T> requires C<T> struct Foo {...

template <typename T> requires C<T> void bar(T t) {...

template <typename T> void bar(T t) requires C<T> {...

// 1行で収まらない場合
template <typename LongName>
requires C<LongName>
struct Foo {...

template <typename LongName>
requires C<LongName>
void bar(LongName ln) {

template <typename LongName>
void bar(LongName ln)
    requires C<LongName> {
```
</dd></dl>
</dd></dl>
<!-- ***************  RequiresClausePosition END  *************** -->

<!-- ***************  SeparateDefinitionBlocks START  *************** -->
<dl><dt>
SeparateDefinitionBlocks(SeparateDefinitionStyle) <font color=green>14以降</font>
</dt><dd>
クラス、構造体、列挙型、関数などの定義ブロックの区切りに、空行を挿入するかを指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Leave          | 変更しない。 |
| Always         | 定義ブロックの区切りに改行を挿入する。 |
| Never          | 定義ブロックの区切りの改行を削除する。 |

<dl><dd>

```C++:Always
#include <cstring>

struct Foo {
  int a, b, c;
};

namespace Ns {
class Bar {
public:
  struct Foobar {
    int a;
    int b;
  };

private:
  int t;

  int method1() {
    // ...
  }

  enum List {
    ITEM1,
    ITEM2
  };

  template <typename T> int method2(T x) {
    // ...
  }

  int i, j, k;

  int method3(int par) {
    // ...
  }
};

class C {};
}
```
```C++:Never
#include <cstring>
struct Foo {
  int a, b, c;
};
namespace Ns {
class Bar {
public:
  struct Foobar {
    int a;
    int b;
  };
private:
  int t;
  int method1() {
    // ...
  }
  enum List {
    ITEM1,
    ITEM2
  };
  template <typename T> int method2(T x) {
    // ...
  }
  int i, j, k;
  int method3(int par) {
    // ...
  }
};
class C {};
}
```
</dd></dl>
</dd></dl>
<!-- ***************  SeparateDefinitionBlocks END  *************** -->

<!-- ***************  ShortNamespaceLines START  *************** -->
<dl><dt>
ShortNamespaceLines(Unsigned) <font color=green>13以降</font>
</dt><dd>
短い名前空間は何行以下であるかについて、行数を指定する。デフォルトは1。<br/>
この値はFixNamespaceCommentsがtrueの場合、終了コメントを追加するために使用する。

<dl><dd>

```C++:ShortNamespaceLines: 0 を指定した場合
// どちらの名前空間も0行より大きいので、FixNamespaceCommentsの動作により名前空間の末尾にコメントを挿入する。
namespace a {
  int foo;
} // namespace a

namespace b {
  int foo;
  int bar;
} // namespace b
```
```C++:ShortNamespaceLines: 1 を指定した場合
// 名前空間aは1行以下なのでコメントの挿入を行わない。bは1行より大きいのでコメントの挿入を行う。
namespace a {
  int foo;
}

namespace b {
  int foo;
  int bar;
} // namespace b
```
</dd></dl>
</dd></dl>
<!-- ***************  ShortNamespaceLines END  *************** -->

<!-- ***************  SortIncludes START  *************** -->
<dl><dt>
SortIncludes(SortIncludesOptions) <font color=green>4以降</font>
</dt><dd>
インクルート文のソート条件について指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Never          | ソートしない。 |
| CaseSensitive  | 大文字と小文字を区別してアスキーコード順にソートを行う。 |
| CaseInsensitive| 大文字と小文字を区別せずアルファベット順にソートを行う。 |
| true           | CaseSensitiveと同じ動作。(レガシーオプション) |
| false          | Neverと同じ動作。(レガシーオプション) |

<dl><dd>

```C++:Never
#include "B/A.h"
#include "A/B.h"
#include "a/b.h"
#include "A/b.h"
#include "B/a.h"
```
```C++:CaseSensitive
#include "A/B.h"
#include "A/b.h"
#include "B/A.h"
#include "B/a.h"
#include "a/b.h"
```
```C++:CaseInsensitive
#include "A/B.h"
#include "A/b.h"
#include "a/b.h"
#include "B/A.h"
#include "B/a.h"
```
</dd></dl>
</dd></dl>
<!-- ***************  SortIncludes END  *************** -->

<!-- ***************  SortJavaStaticImport START  *************** -->
<dl><dt>
SortJavaStaticImport(SortJavaStaticImportOptions) <font color=green>12以降</font>
</dt><dd>
Javaのインポート文の並び順について指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Before         | 静的なインポートを非静的なインポートの前に置く。 |
| After          | 静的なインポートを非静的なインポートの後に置く。 |

<dl><dd>

```C++:Before
import static org.example.function1;

import org.example.ClassA;
```
```C++:After
import org.example.ClassA;

import static org.example.function1;
```
</dd></dl>

::::note info
**メモ書き**
公式ドキュメントに不備あり。JavaStaticImportAfterImportについてはSortJavaStaticImportの誤記の理解。
:::

</dd></dl>
<!-- ***************  SortJavaStaticImport END  *************** -->

<!-- ***************  SortUsingDeclarations START  *************** -->
<dl><dt>
SortUsingDeclarations(Boolean) <font color=green>5以降</font>
</dt><dd>
using宣言のソート方法を指定する。<br/>
ソートは名前空間の単位で行う。また、ソートは大文字小文字を区別せず、アルファベット順で行う。

<dl><dd>

```C++:true
using foo::bar;
using std::cin;
using std::cout;

using ABC::DEF::GHI;
using ABC::XYZ::GHI;
```
```C++:false
using std::cout;
using std::cin;
using foo::bar;

using ABC::XYZ::GHI;
using ABC::DEF::GHI;
```
</dd></dl>
</dd></dl>
<!-- ***************  SortUsingDeclarations END  *************** -->

<!-- ***************  SpaceAfterCStyleCast START  *************** -->
<dl><dt>
SpaceAfterCStyleCast(Boolean) <font color=green>3.5以降</font>
</dt><dd>
C言語キャストの後のスペースを指定する。<br/>

<dl><dd>

```C++:true
// C言語キャストの後にスペースを挿入する
(int) i; 
```
```C++:false
// C言語キャストの後にスペースを挿入しない
(int) i; 
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceAfterCStyleCast END  *************** -->

<!-- ***************  SpaceAfterLogicalNot START  *************** -->
<dl><dt>
SpaceAfterLogicalNot(Boolean) <font color=green>9以降</font>
</dt><dd>
論理否定の後のスペースを指定する。<br/>

<dl><dd>

```C++:true
// 論理否定の後にスペースを挿入する
! someExpression();
```
```C++:false
// 論理否定の後にスペースを挿入しない
!someExpression();
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceAfterLogicalNot END  *************** -->

<!-- ***************  SpaceAfterTemplateKeyword START  *************** -->
<dl><dt>
SpaceAfterTemplateKeyword(Boolean) <font color=green>4以降</font>
</dt><dd>
テンプレートキーワードの後のスペースを指定する。<br/>

<dl><dd>

```C++:true
// テンプレートキーワードの後にスペースを挿入する
template <int> void foo();
```
```C++:false
// テンプレートキーワードの後にスペースを挿入しない
template<int> void foo();
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceAfterTemplateKeyword END  *************** -->

<!-- ***************  SpaceAroundPointerQualifiers START  *************** -->
<dl><dt>
SpaceAroundPointerQualifiers(SpaceAroundPointerQualifiersStyle) <font color=green>12以降</font>
</dt><dd>
ポインタ修飾子(const/volatile)の前後の空白を指定する。<br/>
また、PointerAlignmentの動作とは別で空白の挿入が行われる。

| 値             | 意味 |
|:---------------|:-----|
| Default        | PointerAlignmentで指定した動作とする。 |
| Before         | ポインタ修飾子の前に空白を挿入する。 |
| After          | ポインタ修飾子の後に空白を挿入する。  |
| Both           | ポインタ修飾子の前後に空白を挿入する。  |

<dl><dd>

```C++:Default(PointerAlignment: Leftの場合)
void* const* x = NULL;
```
```C++:Default(PointerAlignment: Rightの場合)
void *const *x = NULL;
```
```C++:Before(PointerAlignment: Leftの場合)
void* const* x = NULL;
```
```C++:Before(PointerAlignment: Rightの場合)
void * const * x = NULL;
```
```C++:After(PointerAlignment: Leftの場合)
void* const * x = NULL;
```
```C++:After(PointerAlignment: Rightの場合)
void *const *x = NULL;
```
```C++:Both(PointerAlignment: Leftの場合)
void* const * x = NULL;
```
```C++:Both(PointerAlignment: Rightの場合)
void * const *x = NULL;
```
</dd></dl>

</dd></dl>
<!-- ***************  SpaceAroundPointerQualifiers END  *************** -->

<!-- ***************  SpaceBeforeAssignmentOperators START  *************** -->
<dl><dt>
SpaceBeforeAssignmentOperators(Boolean) <font color=green>3.7以降</font>
</dt><dd>
代入演算子の前のスペースを指定する。<br/>
<dl><dd>

```C++:true
// 代入演算子の前にスペースを挿入する。
int a = 5;
a += 42;
```
```C++:false
// 代入演算子の前のスペースを削除する。
int a= 5;
a+= 42;
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeAssignmentOperators END  *************** -->

<!-- ***************  SpaceBeforeCaseColon START  *************** -->
<dl><dt>
SpaceBeforeCaseColon(Boolean) <font color=green>12以降</font>
</dt><dd>
caseラベルのコロンの前のスペースを指定する。<br/>
<dl><dd>

```C++:true
// caseラベルのコロンの前にスペースを挿入する。
switch (x) {
  case 1 : break;
}
```
```C++:false
// caseラベルのコロンの前のスペースを削除する。
switch (x) {
  case 1: break;
}
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeCaseColon END  *************** -->

<!-- ***************  SpaceBeforeCpp11BracedList START  *************** -->
<dl><dt>
SpaceBeforeCpp11BracedList(Boolean) <font color=green>7以降</font>
</dt><dd>
C++11の初期化リストの前のスペースを指定する。<br/>
<dl><dd>

```C++:true
// 初期化リストの前にスペースを挿入する。
Foo foo { bar };
Foo {};
vector<int> { 1, 2, 3 };
new int[3] { 1, 2, 3 };
```
```C++:false
// 初期化リストの前のスペースを削除する。
Foo foo{ bar };
Foo{};
vector<int>{ 1, 2, 3 };
new int[3]{ 1, 2, 3 };
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeCpp11BracedList END  *************** -->

<!-- ***************  SpaceBeforeCtorInitializerColon START  *************** -->
<dl><dt>
SpaceBeforeCtorInitializerColon(Boolean) <font color=green>7以降</font>
</dt><dd>
コンストラクタの初期化リストのコロンの前のスペースを指定する。<br/>
<dl><dd>

```C++:true
// コロンの前にスペースを挿入する。
Foo::Foo() : a(a) {} 
```
```C++:false
// コロンの前のスペースを削除する。
Foo::Foo(): a(a) {}
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeCtorInitializerColon END  *************** -->

<!-- ***************  SpaceBeforeInheritanceColon START  *************** -->
<dl><dt>
SpaceBeforeInheritanceColon(Boolean) <font color=green>7以降</font>
</dt><dd>
クラス宣言の継承リストのコロンの前のスペースを指定する。<br/>
<dl><dd>

```C++:true
// コロンの前にスペースを挿入する。
class Foo : Bar {}
```
```C++:false
// コロンの前のスペースを削除する。
class Foo: Bar {} 
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeInheritanceColon END  *************** -->

<!-- ***************  SpaceBeforeParens START  *************** -->
<dl><dt>
SpaceBeforeParens(SpaceBeforeParensStyle) <font color=green>3.5以降</font>
</dt><dd>
丸括弧の前にスペースを挿入する条件を指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Never          | 丸括弧の前の空白を削除する。 |
| ControlStatements| 制御文のキーワード(for/if/while等)の後のみ、丸括弧の前に空白を挿入する。 |
| ControlStatementsExceptControlMacros| ControlStatementsと同じ動作。ただし、ForEachMacros及びIfMacrosにて指定したマクロ名には適用されない。   |
| NonEmptyParentheses| 括弧内が空ではない場合、丸括弧の前に空白を挿入する。 |
| Always         | 構文規約で禁止されている(関数マクロの定義等)又は他のスタイル規則で決められている場合を除き、丸括弧の前に空白を挿入する。  |
| Custom         | SpaceBeforeParensOptionsにより、個別に指定を行う。 |
| false          | Neverと同じ動作。(レガシーオプション)   |
| true           | ControlStatementsと同じ動作。(レガシーオプション)   |
| ControlStatementsExceptForEachMacros| ControlStatementsExceptControlMacrosと同じ動作。(レガシーオプション)  |

<dl><dd>

```C++:Never
void f() {
  if(true) {
    f();
  }
}
```
```C++:ControlStatements
void f() {
  if (true) {
    f();
  }
}
```
```C++:ControlStatementsExceptControlMacros
void f() {
  Q_FOREACH(...) {
    f();
  }
}
```
```C++:NonEmptyParentheses
void() {
  if (true) {
    f();
    g (x, y, z);
  }
}
```
```C++:Always
void f () {
  if (true) {
    f ();
  }
}
```
</dd></dl>

</dd></dl>
<!-- ***************  SpaceBeforeParens END  *************** -->

<!-- ***************  SpaceBeforeParensOptions START  *************** -->
<dl><dt>
SpaceBeforeParensOptions(SpaceBeforeParensCustom) <font color=green>14以降</font>
</dt><dd>
丸括弧の前にスペース制御を個別に指定する。<br/>
SpaceBeforeParensがCustomに指定されている場合、SpaceBeforeParensOptionsで指定した値に従い、スペースの制御を行います。SpaceBeforeParensがCustom以外の場合、この値は無視されます。
<dl><dd>

```yaml:記述例
SpaceBeforeParens: Custom
SpaceBeforeParensOptions:
  AfterControlStatements: true
  AfterFunctionDefinitionName: true
```
</dd></dl>

<!-- ***************  SpaceBeforeParensOptions:AfterControlStatements START  *************** -->
<dl><dt>
AfterControlStatements(Boolean)
</dt><dd>
制御文のキーワード(for/if/while等)と開始括弧の間のスペースを指定する。
<dl><dd>

```C++:true
// スペースを挿入する
if (...) {}
```
```C++:false
// スペースを削除する
if(...) {}
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeParensOptions:AfterControlStatements END  *************** -->

<!-- ***************  SpaceBeforeParensOptions:AfterForeachMacros START  *************** -->
<dl><dt>
AfterForeachMacros(Boolean)
</dt><dd>
ForEachMacrosで指定したマクロと開始括弧の間のスペースを指定する。
<dl><dd>

```C++:true
// スペースを挿入する
FOREACH (...)
  <loop-body>
```
```C++:false
// スペースを削除する
FOREACH(...)
  <loop-body>
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeParensOptions:AfterForeachMacros END  *************** -->

<!-- ***************  SpaceBeforeParensOptions:AfterFunctionDeclarationName START  *************** -->
<dl><dt>
AfterFunctionDeclarationName(Boolean)
</dt><dd>
関数宣言と開始括弧の間のスペースを指定する。
<dl><dd>

```C++:true
// スペースを挿入する
void f ();
```
```C++:false
// スペースを削除する
void f();
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeParensOptions:AfterFunctionDeclarationName END  *************** -->

<!-- ***************  SpaceBeforeParensOptions:AfterFunctionDefinitionName START  *************** -->
<dl><dt>
AfterFunctionDefinitionName(Boolean)
</dt><dd>
関数定義と開始括弧の間のスペースを指定する。
<dl><dd>

```C++:true
// スペースを挿入する
void f () {};
```
```C++:false
// スペースを削除する
void f() {};
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeParensOptions:AfterFunctionDefinitionName END  *************** -->

<!-- ***************  SpaceBeforeParensOptions:AfterIfMacros START  *************** -->
<dl><dt>
AfterIfMacros(Boolean)
</dt><dd>
IfMacrosで指定したマクロと開始括弧の間のスペースを指定する。
<dl><dd>

```C++:true
// スペースを挿入する
IF (...)
  <conditional-body>
```
```C++:false
// スペースを削除する
IF(...)
  <conditional-body>
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeParensOptions:AfterIfMacros END  *************** -->

<!-- ***************  SpaceBeforeParensOptions:AfterIfMacros START  *************** -->
<dl><dt>
AfterIfMacros(Boolean)
</dt><dd>
演算子のオーバーロードと開始括弧の間のスペースを指定する。
<dl><dd>

```C++:true
// スペースを挿入する
void operator++ (int a);
object.operator++ (10); 
```
```C++:false
// スペースを削除する
void operator++(int a);
object.operator++(10); 
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeParensOptions:AfterIfMacros END  *************** -->

<!-- ***************  SpaceBeforeParensOptions:AfterRequiresInClause START  *************** -->
<dl><dt>
AfterRequiresInClause(Boolean)
</dt><dd>
requires句と開始括弧の間のスペースを指定する。
<dl><dd>

```C++:true
// スペースを挿入する
template<typename T>
requires (A<T> && B<T>)
...
```
```C++:false
// スペースを削除する
template<typename T>
requires(A<T> && B<T>)
...
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeParensOptions:AfterRequiresInClause END  *************** -->

<!-- ***************  SpaceBeforeParensOptions:AfterRequiresInExpression START  *************** -->
<dl><dt>
AfterRequiresInExpression(Boolean)
</dt><dd>
requires式と開始括弧の間のスペースを指定する。
<dl><dd>

```C++:true
// スペースを挿入する
template<typename T>
concept C = requires (T t) {
              ...
            }
```
```C++:false
// スペースを削除する
template<typename T>
concept C = requires(T t) {
              ...
            }
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeParensOptions:AfterRequiresInExpression END  *************** -->

<!-- ***************  SpaceBeforeParensOptions:BeforeNonEmptyParentheses START  *************** -->
<dl><dt>
BeforeNonEmptyParentheses(Boolean)
</dt><dd>
括弧内が空ではない場合の、開始括弧の間のスペースを指定する。
<dl><dd>

```C++:true
// 括弧内が空白ではない場合、スペースを挿入する
void f (int a);
f (a);
```
```C++:false
// スペースを削除する
void f();
f();
```
</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeParensOptions:BeforeNonEmptyParentheses END  *************** -->

</dd></dl>
<!-- ***************  SpaceBeforeParensOptions END  *************** -->

<!-- ***************  SpaceBeforeRangeBasedForLoopColon START  *************** -->
<dl><dt>
SpaceBeforeRangeBasedForLoopColon(Boolean) <font color=green>7以降</font>
</dt><dd>
範囲指定でのfor文のコロンの前のスペースを指定する。<br/>
<dl><dd>

```C++:true
// コロンの前にスペースを挿入する。
for (auto v : values) {}
```
```C++:false
// コロンの前のスペースを削除する。
for (auto v: values) {}
```

</dd></dl>

:::note info
**メモ書き**
公式の例ではforの前のスペースについても変更されているが、誤記の理解。(clang-format8.0.1及び15で確認の結果、変更されない)
:::

</dd></dl>
<!-- ***************  SpaceBeforeRangeBasedForLoopColon END  *************** -->

<!-- ***************  SpaceBeforeSquareBrackets START  *************** -->
<dl><dt>
SpaceBeforeSquareBrackets(Boolean) <font color=green>10以降</font>
</dt><dd>
角括弧の前のスペースを指定する。ただし、ラムダ式についてはこの指定の影響を受けない。<br/>
<dl><dd>

```C++:true
// 角括弧の前にスペースを挿入する。
int a [5];
int a [5][5];
```
```C++:false
// 角括弧の前のスペースを削除する。
int a[5];
int a[5][5];
```

</dd></dl>
</dd></dl>
<!-- ***************  SpaceBeforeSquareBrackets END  *************** -->

<!-- ***************  SpaceInEmptyBlock START  *************** -->
<dl><dt>
SpaceInEmptyBlock(Boolean) <font color=green>10以降</font>
</dt><dd>
空白の波括弧の間のスペースを指定する。<br/>
<dl><dd>

```C++:true
// 空白の波括弧の間にスペースを挿入する。
void f() { }
while (true) { }
```
```C++:false
// 空白の波括弧の間のスペースを削除する。
void f() {}
while (true) {}
```

</dd></dl>
</dd></dl>
<!-- ***************  SpaceInEmptyBlock END  *************** -->

<!-- ***************  SpaceInEmptyParentheses START  *************** -->
<dl><dt>
SpaceInEmptyParentheses(Boolean) <font color=green>3.7以降</font>
</dt><dd>
空白の丸括弧の間のスペースを指定する。<br/>
<dl><dd>

```C++:true
// 空白の丸括弧の間にスペースを挿入する。
void f( ) {
  int x[] = {foo( ), bar( )};
  if (true) {
    f( );
  }
}
```
```C++:false
// 空白の丸括弧の間のスペースを削除する。
void f() {
  int x[] = {foo(), bar()};
  if (true) {
    f();
  }
}
```

</dd></dl>
</dd></dl>
<!-- ***************  SpaceInEmptyParentheses END  *************** -->

<!-- ***************  SpacesBeforeTrailingComments START  *************** -->
<dl><dt>
SpacesBeforeTrailingComments(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
行コメント(//)の前のスペースの数を指定する。<br/>
<dl><dd>

```C++:SpacesBeforeTrailingComments: 3 の場合
// 空白の丸括弧の間にスペースを挿入する。
void f() {
  if (true) {   // スペース3個分空白が開く
    f();        // 上に合わせる
  }             // foo
}
```
</dd></dl>
</dd></dl>
<!-- ***************  SpacesBeforeTrailingComments END  *************** -->

<!-- ***************  SpacesInAngles START  *************** -->
<dl><dt>
SpacesInAngles(SpacesInAnglesStyle) <font color=green>3.4以降</font>
</dt><dd>
テンプレートの引数リストの前後の空白を指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Never          | \< の後と > の前のスペースを削除する。 |
| Always         | \< の後と > の前にスペースを挿入する。 |
| Leave          | \< の後と > の前にスペースがあった場合、スペースを1つずつ残す。StandardにCpp03を指定している場合、そちらを優先する。  |
| true           | Alwaysと同じ動作。(レガシーオプション) |
| false          | Neverと同じ動作。(レガシーオプション) |

<dl><dd>

```C++:Never
// 引数リストの前後のスペースを削除する。
static_cast<int>(arg);
std::function<void(int)> fct;
```
```C++:Always
// 引数リストの前後にスペースを挿入する。
static_cast< int >(arg);
std::function< void(int) > fct;
```
</dd></dl>

</dd></dl>
<!-- ***************  SpacesInAngles END  *************** -->

<!-- ***************  SpacesInCStyleCastParentheses START  *************** -->
<dl><dt>
SpacesInCStyleCastParentheses(Boolean) <font color=green>3.7以降</font>
</dt><dd>
C言語キャストの丸括弧内のスペースを指定する。<br/>
<dl><dd>

```C++:true
// 開き丸括弧の後及び閉じ丸括弧の前にスペースを挿入する。
x = ( int32 )y;
```
```C++:false
// 開き丸括弧の後及び閉じ丸括弧の前のスペースを削除する。
x = (int32)y;
```

</dd></dl>
</dd></dl>
<!-- ***************  SpacesInCStyleCastParentheses END  *************** -->

<!-- ***************  SpacesInConditionalStatement START  *************** -->
<dl><dt>
SpacesInConditionalStatement(Boolean) <font color=green>10以降</font>
</dt><dd>
制御文(if, for, switch, while)の丸括弧内のスペースを指定する。<br/>
<dl><dd>

```C++:true
// 開き丸括弧の後及び閉じ丸括弧の前にスペースを挿入する。
if ( a )  { ... }
while ( i < 5 )  { ... }
```
```C++:false
// 開き丸括弧の後及び閉じ丸括弧の前のスペースを削除する。
if (a)  { ... }
while (i < 5)  { ... }
```
</dd></dl>
</dd></dl>
<!-- ***************  SpacesInCStyleCastParentheses END  *************** -->

<!-- ***************  SpacesInContainerLiterals START  *************** -->
<dl><dt>
SpacesInContainerLiterals(Boolean) <font color=green>3.7以降</font>
</dt><dd>
コンテナ・リテラル(Objective-CやJavascriptの配列やdictリテラルなど)内のスペースを指定する。<br/>
<dl><dd>

```JavaScript:true
// コンテナ・リテラル内にスペースを挿入する。
var arr = [ 1, 2, 3 ];
f({a : 1, b : 2, c : 3});
```
```JavaScript:false
// コンテナ・リテラル内のスペースを削除する。
var arr = [1, 2, 3];
f({a: 1, b: 2, c: 3});
```
</dd></dl>
</dd></dl>
<!-- ***************  SpacesInContainerLiterals END  *************** -->

<!-- ***************  SpacesInLineCommentPrefix START  *************** -->
<dl><dt>
SpacesInLineCommentPrefix(SpacesInLineComment) <font color=green>13以降</font>
</dt><dd>
行頭のコメントで許容されるスペースの数の最大値及び最小値を指定する。<br/>
最大値に―1を指定した場合、最大値は無効となる。それ以外の場合、最大値が最小値より優先される。
<dl><dd>

```yaml:書式例
SpacesInLineCommentPrefix:
  Minimum: 1
  Maximum: -1
```

```C++:Minimum: 2、Maximum: -1の場合
//  //の後に2文字スペースが挿入される
//  if (b) {
//    return true;
//  }         
```
```C++:Minimum: 2、Maximum: 1の場合
// //の後に1文字スペースが挿入される(最小は2だが最大が1の為、最大数を設定となる)
// if (b) {
//   return true;
// }         
```
</dd></dl>

</dd></dl>
<!-- ***************  SpacesInLineCommentPrefix END  *************** -->

<!-- ***************  SpacesInParentheses START  *************** -->
<dl><dt>
SpacesInParentheses(Boolean) <font color=green>3.7以降</font>
</dt><dd>
丸括弧内の前後のスペースを指定する。<br/>
<dl><dd>

```C++:true
// 開き丸括弧の後及び閉じ丸括弧の前にスペースを挿入する。
t f( Deleted & ) & = delete;
```
```C++:false
// 開き丸括弧の後及び閉じ丸括弧の前のスペースを削除する。
t f(Deleted &) & = delete;
```
</dd></dl>
</dd></dl>
<!-- ***************  SpacesInParentheses END  *************** -->

<!-- ***************  SpacesInSquareBrackets START  *************** -->
<dl><dt>
SpacesInSquareBrackets(Boolean) <font color=green>3.7以降</font>
</dt><dd>
角括弧内の前後のスペースを指定する。ただしラムダ式と値の無い角括弧のブロックについては対象外とする。<br/>
<dl><dd>

```C++:true
// 開き角括弧の後及び閉じ角括弧の前にスペースを挿入する。
int a[ 5 ];
std::unique_ptr<int[]> foo() {} // 値の無い角括弧は対象外
```
```C++:false
// 開き角括弧の後及び閉じ角括弧の前のスペースを削除する。
int a[5];
```
</dd></dl>
</dd></dl>
<!-- ***************  SpacesInSquareBrackets END  *************** -->

<!-- ***************  Standard START  *************** -->
<dl><dt>
Standard(LanguageStandard) <font color=green>3.7以降</font>
</dt><dd>
対象とするC++の規格を指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| c++03<br/>C++03<br/>Cpp03 | C++03を指定する。 |
| c++11<br/>Cpp11| C++11を指定する。 |
| c++14          | C++17を指定する。 |
| c++17          | C++14を指定する。 |
| c++20          | C++20を指定する。 |
| Latest         | Latestを指定する。動作としてはC++11と同じになる。 |
| Auto           | 自動で判別を行う。 |

<dl><dd>
</dd></dl>

</dd></dl>
<!-- ***************  Standard END  *************** -->

<!-- ***************  StatementAttributeLikeMacros START  *************** -->
<dl><dt>
StatementAttributeLikeMacros(List of Strings) <font color=green>12以降</font>
</dt><dd>
識別子として解釈させず、属性と同じように無視されるキーワードを指定する。<br/>
Qtのemitなどを識別子として処理させないための定義である。<br/>

<dl><dd>

```yaml:書式例
StatementAttributeLikeMacros: ['emit', 'Q_EMIT']
```
```C++:StatementAttributeLikeMacros: [] を指定した場合
unsigned char data = 'x';
emit          signal(data); // emitを識別子と勘違いしてしまい、おかしな並び方になる
```
```C++:StatementAttributeLikeMacros: ['emit'] を指定した場合
unsigned char data = 'x';
emit signal(data); // emitを識別子と認識させない
```
</dd></dl>
</dd></dl>
<!-- ***************  StatementAttributeLikeMacros END  *************** -->

<!-- ***************  StatementMacros START  *************** -->
<dl><dt>
StatementMacros(List of Strings) <font color=green>8以降</font>
</dt><dd>
完全な式として解釈されるべきマクロを指定する。<br/>

<dl><dd>

```yaml:書式例
StatementMacros: ['Q_UNUSED', 'QT_REQUIRE_VERSION']
```
</dd></dl>
</dd></dl>
<!-- ***************  StatementMacros END  *************** -->

<!-- ***************  TabWidth START  *************** -->
<dl><dt>
TabWidth(Unsigned) <font color=green>3.7以降</font>
</dt><dd>
タブ文字の数を指定する。<br/>
</dd></dl>
<!-- ***************  TabWidth END  *************** -->

<!-- ***************  TypenameMacros START  *************** -->
<dl><dt>
TypenameMacros(List of Strings) <font color=green>9以降</font>
</dt><dd>
関数呼び出しとしてではなく、型宣言として解釈されるべきマクロを指定する。<br/>

<dl><dd>

```yaml:書式例
TypenameMacros: ['STACK_OF', 'LIST']
```
</dd></dl>
</dd></dl>
<!-- ***************  TypenameMacros END  *************** -->

<!-- ***************  UseCRLF START  *************** -->
<dl><dt>
UseCRLF(Unsigned) <font color=green>10以降</font>
</dt><dd>
ファイル内の改行コードを指定する。<br/>
trueを指定した場合、ファイルの改行コードをCR+LFで統一する。DeriveLineEndingにtrueの場合、このフラグは無効となる。<br/>
</dd></dl>
<!-- ***************  UseCRLF END  *************** -->

<!-- ***************  UseTab START  *************** -->
<dl><dt>
UseTab(UseTabStyle) <font color=green>3.7以降</font>
</dt><dd>
変換結果のファイルでのタブの使用について指定する。<br/>

| 値             | 意味 |
|:---------------|:-----|
| Never          | タブを使用しない。 |
| ForIndentation | インデントについてのみタブを使用する。 |
| ForContinuationAndIndentation | 先頭の空白はすべてタブで埋め、行内に現れるアライメント(連続した代入や宣言など)にはスペースを使用する。 |
| AlignWithSpaces| 行の継続とインデントにはタブを使用し、整列にはスペースを使用します。 |
| Always         | 少なくとも1つのタブストップから次のタブストップまでの空白を埋める必要がある場合は、タブを使用します。 |
| true           | Alwaysと同じ動作を行う。(レガシーオプション) |
| false          | Neverと同じ動作を行う。(レガシーオプション) |

<dl><dd>
</dd></dl>

</dd></dl>
<!-- ***************  UseTab END  *************** -->

<!-- ***************  WhitespaceSensitiveMacros START  *************** -->
<dl><dt>
WhitespaceSensitiveMacros(List of Strings) <font color=green>11以降</font>
</dt><dd>
ホワイトスペースが影響する変更をかけてはいけないマクロを指定する。<br/>
<dl><dd>

```yaml:書式例
WhitespaceSensitiveMacros: ['STRINGIZE', 'PP_STRINGIZE']
```
</dd></dl>
</dd></dl>
<!-- ***************  WhitespaceSensitiveMacros END  *************** -->

## ３. 書式例

Clang-Format15でのLLVMの既定値を以下に示す。

```yaml:
---
Language:        Cpp
# BasedOnStyle:  LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignArrayOfStructures: None
AlignConsecutiveMacros: None
AlignConsecutiveAssignments: None
AlignConsecutiveBitFields: None
AlignConsecutiveDeclarations: None
AlignEscapedNewlines: Right
AlignOperands:   Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortEnumsOnASingleLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
AttributeMacros:
  - __capability
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
  AfterCaseLabel:  false
  AfterClass:      false
  AfterControlStatement: Never
  AfterEnum:       false
  AfterFunction:   false
  AfterNamespace:  false
  AfterObjCDeclaration: false
  AfterStruct:     false
  AfterUnion:      false
  AfterExternBlock: false
  BeforeCatch:     false
  BeforeElse:      false
  BeforeLambdaBody: false
  BeforeWhile:     false
  IndentBraces:    false
  SplitEmptyFunction: true
  SplitEmptyRecord: true
  SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeConceptDeclarations: true
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit:     80
CommentPragmas:  '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat:   false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: LogicalBlock
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
  - foreach
  - Q_FOREACH
  - BOOST_FOREACH
IfMacros:
  - KJ_IF_MAYBE
IncludeBlocks:   Preserve
IncludeCategories:
  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
    Priority:        2
    SortPriority:    0
    CaseSensitive:   false
  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
    Priority:        3
    SortPriority:    0
    CaseSensitive:   false
  - Regex:           '.*'
    Priority:        1
    SortPriority:    0
    CaseSensitive:   false
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentAccessModifiers: false
IndentCaseLabels: false
IndentCaseBlocks: false
IndentGotoLabels: true
IndentPPDirectives: None
IndentExternBlock: AfterExternBlock
IndentRequires:  false
IndentWidth:     2
IndentWrappedFunctionNames: false
InsertTrailingCommas: None
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
LambdaBodyIndentation: Signature
MacroBlockBegin: ''
MacroBlockEnd:   ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PenaltyIndentedWhitespace: 0
PointerAlignment: Right
PPIndentWidth:   -1
ReferenceAlignment: Pointer
ReflowComments:  true
ShortNamespaceLines: 1
SortIncludes:    CaseSensitive
SortJavaStaticImport: Before
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceAroundPointerQualifiers: Default
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles:  Never
SpacesInConditionalStatement: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInLineCommentPrefix:
  Minimum:         1
  Maximum:         -1
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
BitFieldColonSpacing: Both
Standard:        Latest
StatementAttributeLikeMacros:
  - Q_EMIT
StatementMacros:
  - Q_UNUSED
  - QT_REQUIRE_VERSION
TabWidth:        8
UseCRLF:         false
UseTab:          Never
WhitespaceSensitiveMacros:
  - STRINGIZE
  - PP_STRINGIZE
  - BOOST_PP_STRINGIZE
  - NS_SWIFT_NAME
  - CF_SWIFT_NAME
...
```