1========================== 2Clang-Format Style Options 3========================== 4 5:doc:`ClangFormatStyleOptions` describes configurable formatting style options 6supported by :doc:`LibFormat` and :doc:`ClangFormat`. 7 8When using :program:`clang-format` command line utility or 9``clang::format::reformat(...)`` functions from code, one can either use one of 10the predefined styles (LLVM, Google, Chromium, Mozilla, WebKit, Microsoft) or 11create a custom style by configuring specific style options. 12 13 14Configuring Style with clang-format 15=================================== 16 17:program:`clang-format` supports two ways to provide custom style options: 18directly specify style configuration in the ``-style=`` command line option or 19use ``-style=file`` and put style configuration in the ``.clang-format`` or 20``_clang-format`` file in the project directory. 21 22When using ``-style=file``, :program:`clang-format` for each input file will 23try to find the ``.clang-format`` file located in the closest parent directory 24of the input file. When the standard input is used, the search is started from 25the current directory. 26 27The ``.clang-format`` file uses YAML format: 28 29.. code-block:: yaml 30 31 key1: value1 32 key2: value2 33 # A comment. 34 ... 35 36The configuration file can consist of several sections each having different 37``Language:`` parameter denoting the programming language this section of the 38configuration is targeted at. See the description of the **Language** option 39below for the list of supported languages. The first section may have no 40language set, it will set the default style options for all lanugages. 41Configuration sections for specific language will override options set in the 42default section. 43 44When :program:`clang-format` formats a file, it auto-detects the language using 45the file name. When formatting standard input or a file that doesn't have the 46extension corresponding to its language, ``-assume-filename=`` option can be 47used to override the file name :program:`clang-format` uses to detect the 48language. 49 50An example of a configuration file for multiple languages: 51 52.. code-block:: yaml 53 54 --- 55 # We'll use defaults from the LLVM style, but with 4 columns indentation. 56 BasedOnStyle: LLVM 57 IndentWidth: 4 58 --- 59 Language: Cpp 60 # Force pointers to the type for C++. 61 DerivePointerAlignment: false 62 PointerAlignment: Left 63 --- 64 Language: JavaScript 65 # Use 100 columns for JS. 66 ColumnLimit: 100 67 --- 68 Language: Proto 69 # Don't format .proto files. 70 DisableFormat: true 71 --- 72 Language: CSharp 73 # Use 100 columns for C#. 74 ColumnLimit: 100 75 ... 76 77An easy way to get a valid ``.clang-format`` file containing all configuration 78options of a certain predefined style is: 79 80.. code-block:: console 81 82 clang-format -style=llvm -dump-config > .clang-format 83 84When specifying configuration in the ``-style=`` option, the same configuration 85is applied for all input files. The format of the configuration is: 86 87.. code-block:: console 88 89 -style='{key1: value1, key2: value2, ...}' 90 91 92Disabling Formatting on a Piece of Code 93======================================= 94 95Clang-format understands also special comments that switch formatting in a 96delimited range. The code between a comment ``// clang-format off`` or 97``/* clang-format off */`` up to a comment ``// clang-format on`` or 98``/* clang-format on */`` will not be formatted. The comments themselves 99will be formatted (aligned) normally. 100 101.. code-block:: c++ 102 103 int formatted_code; 104 // clang-format off 105 void unformatted_code ; 106 // clang-format on 107 void formatted_code_again; 108 109 110Configuring Style in Code 111========================= 112 113When using ``clang::format::reformat(...)`` functions, the format is specified 114by supplying the `clang::format::FormatStyle 115<https://clang.llvm.org/doxygen/structclang_1_1format_1_1FormatStyle.html>`_ 116structure. 117 118 119Configurable Format Style Options 120================================= 121 122This section lists the supported style options. Value type is specified for 123each option. For enumeration types possible values are specified both as a C++ 124enumeration member (with a prefix, e.g. ``LS_Auto``), and as a value usable in 125the configuration (without a prefix: ``Auto``). 126 127 128**BasedOnStyle** (``string``) 129 The style used for all options not specifically set in the configuration. 130 131 This option is supported only in the :program:`clang-format` configuration 132 (both within ``-style='{...}'`` and the ``.clang-format`` file). 133 134 Possible values: 135 136 * ``LLVM`` 137 A style complying with the `LLVM coding standards 138 <https://llvm.org/docs/CodingStandards.html>`_ 139 * ``Google`` 140 A style complying with `Google's C++ style guide 141 <https://google.github.io/styleguide/cppguide.html>`_ 142 * ``Chromium`` 143 A style complying with `Chromium's style guide 144 <https://chromium.googlesource.com/chromium/src/+/master/styleguide/styleguide.md>`_ 145 * ``Mozilla`` 146 A style complying with `Mozilla's style guide 147 <https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style>`_ 148 * ``WebKit`` 149 A style complying with `WebKit's style guide 150 <https://www.webkit.org/coding/coding-style.html>`_ 151 * ``Microsoft`` 152 A style complying with `Microsoft's style guide 153 <https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017>`_ 154 155.. START_FORMAT_STYLE_OPTIONS 156 157**AccessModifierOffset** (``int``) 158 The extra indent or outdent of access modifiers, e.g. ``public:``. 159 160**AlignAfterOpenBracket** (``BracketAlignmentStyle``) 161 If ``true``, horizontally aligns arguments after an open bracket. 162 163 This applies to round brackets (parentheses), angle brackets and square 164 brackets. 165 166 Possible values: 167 168 * ``BAS_Align`` (in configuration: ``Align``) 169 Align parameters on the open bracket, e.g.: 170 171 .. code-block:: c++ 172 173 someLongFunction(argument1, 174 argument2); 175 176 * ``BAS_DontAlign`` (in configuration: ``DontAlign``) 177 Don't align, instead use ``ContinuationIndentWidth``, e.g.: 178 179 .. code-block:: c++ 180 181 someLongFunction(argument1, 182 argument2); 183 184 * ``BAS_AlwaysBreak`` (in configuration: ``AlwaysBreak``) 185 Always break after an open bracket, if the parameters don't fit 186 on a single line, e.g.: 187 188 .. code-block:: c++ 189 190 someLongFunction( 191 argument1, argument2); 192 193 194 195**AlignConsecutiveAssignments** (``bool``) 196 If ``true``, aligns consecutive assignments. 197 198 This will align the assignment operators of consecutive lines. This 199 will result in formattings like 200 201 .. code-block:: c++ 202 203 int aaaa = 12; 204 int b = 23; 205 int ccc = 23; 206 207**AlignConsecutiveDeclarations** (``bool``) 208 If ``true``, aligns consecutive declarations. 209 210 This will align the declaration names of consecutive lines. This 211 will result in formattings like 212 213 .. code-block:: c++ 214 215 int aaaa = 12; 216 float b = 23; 217 std::string ccc = 23; 218 219**AlignConsecutiveMacros** (``bool``) 220 If ``true``, aligns consecutive C/C++ preprocessor macros. 221 222 This will align C/C++ preprocessor macros of consecutive lines. 223 Will result in formattings like 224 225 .. code-block:: c++ 226 227 #define SHORT_NAME 42 228 #define LONGER_NAME 0x007f 229 #define EVEN_LONGER_NAME (2) 230 #define foo(x) (x * x) 231 #define bar(y, z) (y + z) 232 233**AlignEscapedNewlines** (``EscapedNewlineAlignmentStyle``) 234 Options for aligning backslashes in escaped newlines. 235 236 Possible values: 237 238 * ``ENAS_DontAlign`` (in configuration: ``DontAlign``) 239 Don't align escaped newlines. 240 241 .. code-block:: c++ 242 243 #define A \ 244 int aaaa; \ 245 int b; \ 246 int dddddddddd; 247 248 * ``ENAS_Left`` (in configuration: ``Left``) 249 Align escaped newlines as far left as possible. 250 251 .. code-block:: c++ 252 253 true: 254 #define A \ 255 int aaaa; \ 256 int b; \ 257 int dddddddddd; 258 259 false: 260 261 * ``ENAS_Right`` (in configuration: ``Right``) 262 Align escaped newlines in the right-most column. 263 264 .. code-block:: c++ 265 266 #define A \ 267 int aaaa; \ 268 int b; \ 269 int dddddddddd; 270 271 272 273**AlignOperands** (``bool``) 274 If ``true``, horizontally align operands of binary and ternary 275 expressions. 276 277 Specifically, this aligns operands of a single expression that needs to be 278 split over multiple lines, e.g.: 279 280 .. code-block:: c++ 281 282 int aaa = bbbbbbbbbbbbbbb + 283 ccccccccccccccc; 284 285**AlignTrailingComments** (``bool``) 286 If ``true``, aligns trailing comments. 287 288 .. code-block:: c++ 289 290 true: false: 291 int a; // My comment a vs. int a; // My comment a 292 int b = 2; // comment b int b = 2; // comment about b 293 294**AllowAllArgumentsOnNextLine** (``bool``) 295 If a function call or braced initializer list doesn't fit on a 296 line, allow putting all arguments onto the next line, even if 297 ``BinPackArguments`` is ``false``. 298 299 .. code-block:: c++ 300 301 true: 302 callFunction( 303 a, b, c, d); 304 305 false: 306 callFunction(a, 307 b, 308 c, 309 d); 310 311**AllowAllConstructorInitializersOnNextLine** (``bool``) 312 If a constructor definition with a member initializer list doesn't 313 fit on a single line, allow putting all member initializers onto the next 314 line, if ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is true. 315 Note that this parameter has no effect if 316 ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is false. 317 318 .. code-block:: c++ 319 320 true: 321 MyClass::MyClass() : 322 member0(0), member1(2) {} 323 324 false: 325 MyClass::MyClass() : 326 member0(0), 327 member1(2) {} 328 329**AllowAllParametersOfDeclarationOnNextLine** (``bool``) 330 If the function declaration doesn't fit on a line, 331 allow putting all parameters of a function declaration onto 332 the next line even if ``BinPackParameters`` is ``false``. 333 334 .. code-block:: c++ 335 336 true: 337 void myFunction( 338 int a, int b, int c, int d, int e); 339 340 false: 341 void myFunction(int a, 342 int b, 343 int c, 344 int d, 345 int e); 346 347**AllowShortBlocksOnASingleLine** (``ShortBlockStyle``) 348 Dependent on the value, ``while (true) { continue; }`` can be put on a 349 single line. 350 351 Possible values: 352 353 * ``SBS_Never`` (in configuration: ``Never``) 354 Never merge blocks into a single line. 355 356 .. code-block:: c++ 357 358 while (true) { 359 } 360 while (true) { 361 continue; 362 } 363 364 * ``SBS_Empty`` (in configuration: ``Empty``) 365 Only merge empty blocks. 366 367 .. code-block:: c++ 368 369 while (true) {} 370 while (true) { 371 continue; 372 } 373 374 * ``SBS_Always`` (in configuration: ``Always``) 375 Always merge short blocks into a single line. 376 377 .. code-block:: c++ 378 379 while (true) {} 380 while (true) { continue; } 381 382 383 384**AllowShortCaseLabelsOnASingleLine** (``bool``) 385 If ``true``, short case labels will be contracted to a single line. 386 387 .. code-block:: c++ 388 389 true: false: 390 switch (a) { vs. switch (a) { 391 case 1: x = 1; break; case 1: 392 case 2: return; x = 1; 393 } break; 394 case 2: 395 return; 396 } 397 398**AllowShortFunctionsOnASingleLine** (``ShortFunctionStyle``) 399 Dependent on the value, ``int f() { return 0; }`` can be put on a 400 single line. 401 402 Possible values: 403 404 * ``SFS_None`` (in configuration: ``None``) 405 Never merge functions into a single line. 406 407 * ``SFS_InlineOnly`` (in configuration: ``InlineOnly``) 408 Only merge functions defined inside a class. Same as "inline", 409 except it does not implies "empty": i.e. top level empty functions 410 are not merged either. 411 412 .. code-block:: c++ 413 414 class Foo { 415 void f() { foo(); } 416 }; 417 void f() { 418 foo(); 419 } 420 void f() { 421 } 422 423 * ``SFS_Empty`` (in configuration: ``Empty``) 424 Only merge empty functions. 425 426 .. code-block:: c++ 427 428 void f() {} 429 void f2() { 430 bar2(); 431 } 432 433 * ``SFS_Inline`` (in configuration: ``Inline``) 434 Only merge functions defined inside a class. Implies "empty". 435 436 .. code-block:: c++ 437 438 class Foo { 439 void f() { foo(); } 440 }; 441 void f() { 442 foo(); 443 } 444 void f() {} 445 446 * ``SFS_All`` (in configuration: ``All``) 447 Merge all functions fitting on a single line. 448 449 .. code-block:: c++ 450 451 class Foo { 452 void f() { foo(); } 453 }; 454 void f() { bar(); } 455 456 457 458**AllowShortIfStatementsOnASingleLine** (``ShortIfStyle``) 459 If ``true``, ``if (a) return;`` can be put on a single line. 460 461 Possible values: 462 463 * ``SIS_Never`` (in configuration: ``Never``) 464 Never put short ifs on the same line. 465 466 .. code-block:: c++ 467 468 if (a) 469 return ; 470 else { 471 return; 472 } 473 474 * ``SIS_WithoutElse`` (in configuration: ``WithoutElse``) 475 Without else put short ifs on the same line only if 476 the else is not a compound statement. 477 478 .. code-block:: c++ 479 480 if (a) return; 481 else 482 return; 483 484 * ``SIS_Always`` (in configuration: ``Always``) 485 Always put short ifs on the same line if 486 the else is not a compound statement or not. 487 488 .. code-block:: c++ 489 490 if (a) return; 491 else { 492 return; 493 } 494 495 496 497**AllowShortLambdasOnASingleLine** (``ShortLambdaStyle``) 498 Dependent on the value, ``auto lambda []() { return 0; }`` can be put on a 499 single line. 500 501 Possible values: 502 503 * ``SLS_None`` (in configuration: ``None``) 504 Never merge lambdas into a single line. 505 506 * ``SLS_Empty`` (in configuration: ``Empty``) 507 Only merge empty lambdas. 508 509 .. code-block:: c++ 510 511 auto lambda = [](int a) {} 512 auto lambda2 = [](int a) { 513 return a; 514 }; 515 516 * ``SLS_Inline`` (in configuration: ``Inline``) 517 Merge lambda into a single line if argument of a function. 518 519 .. code-block:: c++ 520 521 auto lambda = [](int a) { 522 return a; 523 }; 524 sort(a.begin(), a.end(), ()[] { return x < y; }) 525 526 * ``SLS_All`` (in configuration: ``All``) 527 Merge all lambdas fitting on a single line. 528 529 .. code-block:: c++ 530 531 auto lambda = [](int a) {} 532 auto lambda2 = [](int a) { return a; }; 533 534 535 536**AllowShortLoopsOnASingleLine** (``bool``) 537 If ``true``, ``while (true) continue;`` can be put on a single 538 line. 539 540**AlwaysBreakAfterDefinitionReturnType** (``DefinitionReturnTypeBreakingStyle``) 541 The function definition return type breaking style to use. This 542 option is **deprecated** and is retained for backwards compatibility. 543 544 Possible values: 545 546 * ``DRTBS_None`` (in configuration: ``None``) 547 Break after return type automatically. 548 ``PenaltyReturnTypeOnItsOwnLine`` is taken into account. 549 550 * ``DRTBS_All`` (in configuration: ``All``) 551 Always break after the return type. 552 553 * ``DRTBS_TopLevel`` (in configuration: ``TopLevel``) 554 Always break after the return types of top-level functions. 555 556 557 558**AlwaysBreakAfterReturnType** (``ReturnTypeBreakingStyle``) 559 The function declaration return type breaking style to use. 560 561 Possible values: 562 563 * ``RTBS_None`` (in configuration: ``None``) 564 Break after return type automatically. 565 ``PenaltyReturnTypeOnItsOwnLine`` is taken into account. 566 567 .. code-block:: c++ 568 569 class A { 570 int f() { return 0; }; 571 }; 572 int f(); 573 int f() { return 1; } 574 575 * ``RTBS_All`` (in configuration: ``All``) 576 Always break after the return type. 577 578 .. code-block:: c++ 579 580 class A { 581 int 582 f() { 583 return 0; 584 }; 585 }; 586 int 587 f(); 588 int 589 f() { 590 return 1; 591 } 592 593 * ``RTBS_TopLevel`` (in configuration: ``TopLevel``) 594 Always break after the return types of top-level functions. 595 596 .. code-block:: c++ 597 598 class A { 599 int f() { return 0; }; 600 }; 601 int 602 f(); 603 int 604 f() { 605 return 1; 606 } 607 608 * ``RTBS_AllDefinitions`` (in configuration: ``AllDefinitions``) 609 Always break after the return type of function definitions. 610 611 .. code-block:: c++ 612 613 class A { 614 int 615 f() { 616 return 0; 617 }; 618 }; 619 int f(); 620 int 621 f() { 622 return 1; 623 } 624 625 * ``RTBS_TopLevelDefinitions`` (in configuration: ``TopLevelDefinitions``) 626 Always break after the return type of top-level definitions. 627 628 .. code-block:: c++ 629 630 class A { 631 int f() { return 0; }; 632 }; 633 int f(); 634 int 635 f() { 636 return 1; 637 } 638 639 640 641**AlwaysBreakBeforeMultilineStrings** (``bool``) 642 If ``true``, always break before multiline string literals. 643 644 This flag is mean to make cases where there are multiple multiline strings 645 in a file look more consistent. Thus, it will only take effect if wrapping 646 the string at that point leads to it being indented 647 ``ContinuationIndentWidth`` spaces from the start of the line. 648 649 .. code-block:: c++ 650 651 true: false: 652 aaaa = vs. aaaa = "bbbb" 653 "bbbb" "cccc"; 654 "cccc"; 655 656**AlwaysBreakTemplateDeclarations** (``BreakTemplateDeclarationsStyle``) 657 The template declaration breaking style to use. 658 659 Possible values: 660 661 * ``BTDS_No`` (in configuration: ``No``) 662 Do not force break before declaration. 663 ``PenaltyBreakTemplateDeclaration`` is taken into account. 664 665 .. code-block:: c++ 666 667 template <typename T> T foo() { 668 } 669 template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa, 670 int bbbbbbbbbbbbbbbbbbbbb) { 671 } 672 673 * ``BTDS_MultiLine`` (in configuration: ``MultiLine``) 674 Force break after template declaration only when the following 675 declaration spans multiple lines. 676 677 .. code-block:: c++ 678 679 template <typename T> T foo() { 680 } 681 template <typename T> 682 T foo(int aaaaaaaaaaaaaaaaaaaaa, 683 int bbbbbbbbbbbbbbbbbbbbb) { 684 } 685 686 * ``BTDS_Yes`` (in configuration: ``Yes``) 687 Always break after template declaration. 688 689 .. code-block:: c++ 690 691 template <typename T> 692 T foo() { 693 } 694 template <typename T> 695 T foo(int aaaaaaaaaaaaaaaaaaaaa, 696 int bbbbbbbbbbbbbbbbbbbbb) { 697 } 698 699 700 701**BinPackArguments** (``bool``) 702 If ``false``, a function call's arguments will either be all on the 703 same line or will have one line each. 704 705 .. code-block:: c++ 706 707 true: 708 void f() { 709 f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa, 710 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); 711 } 712 713 false: 714 void f() { 715 f(aaaaaaaaaaaaaaaaaaaa, 716 aaaaaaaaaaaaaaaaaaaa, 717 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); 718 } 719 720**BinPackParameters** (``bool``) 721 If ``false``, a function declaration's or function definition's 722 parameters will either all be on the same line or will have one line each. 723 724 .. code-block:: c++ 725 726 true: 727 void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa, 728 int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {} 729 730 false: 731 void f(int aaaaaaaaaaaaaaaaaaaa, 732 int aaaaaaaaaaaaaaaaaaaa, 733 int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {} 734 735**BraceWrapping** (``BraceWrappingFlags``) 736 Control of individual brace wrapping cases. 737 738 If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how 739 each individual brace case should be handled. Otherwise, this is ignored. 740 741 .. code-block:: yaml 742 743 # Example of usage: 744 BreakBeforeBraces: Custom 745 BraceWrapping: 746 AfterEnum: true 747 AfterStruct: false 748 SplitEmptyFunction: false 749 750 Nested configuration flags: 751 752 753 * ``bool AfterCaseLabel`` Wrap case labels. 754 755 .. code-block:: c++ 756 757 false: true: 758 switch (foo) { vs. switch (foo) { 759 case 1: { case 1: 760 bar(); { 761 break; bar(); 762 } break; 763 default: { } 764 plop(); default: 765 } { 766 } plop(); 767 } 768 } 769 770 * ``bool AfterClass`` Wrap class definitions. 771 772 .. code-block:: c++ 773 774 true: 775 class foo {}; 776 777 false: 778 class foo 779 {}; 780 781 * ``BraceWrappingAfterControlStatementStyle AfterControlStatement`` 782 Wrap control statements (``if``/``for``/``while``/``switch``/..). 783 784 Possible values: 785 786 * ``BWACS_Never`` (in configuration: ``Never``) 787 Never wrap braces after a control statement. 788 789 .. code-block:: c++ 790 791 if (foo()) { 792 } else { 793 } 794 for (int i = 0; i < 10; ++i) { 795 } 796 797 * ``BWACS_MultiLine`` (in configuration: ``MultiLine``) 798 Only wrap braces after a multi-line control statement. 799 800 .. code-block:: c++ 801 802 if (foo && bar && 803 baz) 804 { 805 quux(); 806 } 807 while (foo || bar) { 808 } 809 810 * ``BWACS_Always`` (in configuration: ``Always``) 811 Always wrap braces after a control statement. 812 813 .. code-block:: c++ 814 815 if (foo()) 816 { 817 } else 818 {} 819 for (int i = 0; i < 10; ++i) 820 {} 821 822 823 * ``bool AfterEnum`` Wrap enum definitions. 824 825 .. code-block:: c++ 826 827 true: 828 enum X : int 829 { 830 B 831 }; 832 833 false: 834 enum X : int { B }; 835 836 * ``bool AfterFunction`` Wrap function definitions. 837 838 .. code-block:: c++ 839 840 true: 841 void foo() 842 { 843 bar(); 844 bar2(); 845 } 846 847 false: 848 void foo() { 849 bar(); 850 bar2(); 851 } 852 853 * ``bool AfterNamespace`` Wrap namespace definitions. 854 855 .. code-block:: c++ 856 857 true: 858 namespace 859 { 860 int foo(); 861 int bar(); 862 } 863 864 false: 865 namespace { 866 int foo(); 867 int bar(); 868 } 869 870 * ``bool AfterObjCDeclaration`` Wrap ObjC definitions (interfaces, implementations...). 871 @autoreleasepool and @synchronized blocks are wrapped 872 according to `AfterControlStatement` flag. 873 874 * ``bool AfterStruct`` Wrap struct definitions. 875 876 .. code-block:: c++ 877 878 true: 879 struct foo 880 { 881 int x; 882 }; 883 884 false: 885 struct foo { 886 int x; 887 }; 888 889 * ``bool AfterUnion`` Wrap union definitions. 890 891 .. code-block:: c++ 892 893 true: 894 union foo 895 { 896 int x; 897 } 898 899 false: 900 union foo { 901 int x; 902 } 903 904 * ``bool AfterExternBlock`` Wrap extern blocks. 905 906 .. code-block:: c++ 907 908 true: 909 extern "C" 910 { 911 int foo(); 912 } 913 914 false: 915 extern "C" { 916 int foo(); 917 } 918 919 * ``bool BeforeCatch`` Wrap before ``catch``. 920 921 .. code-block:: c++ 922 923 true: 924 try { 925 foo(); 926 } 927 catch () { 928 } 929 930 false: 931 try { 932 foo(); 933 } catch () { 934 } 935 936 * ``bool BeforeElse`` Wrap before ``else``. 937 938 .. code-block:: c++ 939 940 true: 941 if (foo()) { 942 } 943 else { 944 } 945 946 false: 947 if (foo()) { 948 } else { 949 } 950 951 * ``bool IndentBraces`` Indent the wrapped braces themselves. 952 953 * ``bool SplitEmptyFunction`` If ``false``, empty function body can be put on a single line. 954 This option is used only if the opening brace of the function has 955 already been wrapped, i.e. the `AfterFunction` brace wrapping mode is 956 set, and the function could/should not be put on a single line (as per 957 `AllowShortFunctionsOnASingleLine` and constructor formatting options). 958 959 .. code-block:: c++ 960 961 int f() vs. int f() 962 {} { 963 } 964 965 * ``bool SplitEmptyRecord`` If ``false``, empty record (e.g. class, struct or union) body 966 can be put on a single line. This option is used only if the opening 967 brace of the record has already been wrapped, i.e. the `AfterClass` 968 (for classes) brace wrapping mode is set. 969 970 .. code-block:: c++ 971 972 class Foo vs. class Foo 973 {} { 974 } 975 976 * ``bool SplitEmptyNamespace`` If ``false``, empty namespace body can be put on a single line. 977 This option is used only if the opening brace of the namespace has 978 already been wrapped, i.e. the `AfterNamespace` brace wrapping mode is 979 set. 980 981 .. code-block:: c++ 982 983 namespace Foo vs. namespace Foo 984 {} { 985 } 986 987 988**BreakAfterJavaFieldAnnotations** (``bool``) 989 Break after each annotation on a field in Java files. 990 991 .. code-block:: java 992 993 true: false: 994 @Partial vs. @Partial @Mock DataLoad loader; 995 @Mock 996 DataLoad loader; 997 998**BreakBeforeBinaryOperators** (``BinaryOperatorStyle``) 999 The way to wrap binary operators. 1000 1001 Possible values: 1002 1003 * ``BOS_None`` (in configuration: ``None``) 1004 Break after operators. 1005 1006 .. code-block:: c++ 1007 1008 LooooooooooongType loooooooooooooooooooooongVariable = 1009 someLooooooooooooooooongFunction(); 1010 1011 bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + 1012 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == 1013 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && 1014 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > 1015 ccccccccccccccccccccccccccccccccccccccccc; 1016 1017 * ``BOS_NonAssignment`` (in configuration: ``NonAssignment``) 1018 Break before operators that aren't assignments. 1019 1020 .. code-block:: c++ 1021 1022 LooooooooooongType loooooooooooooooooooooongVariable = 1023 someLooooooooooooooooongFunction(); 1024 1025 bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1026 + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1027 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1028 && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1029 > ccccccccccccccccccccccccccccccccccccccccc; 1030 1031 * ``BOS_All`` (in configuration: ``All``) 1032 Break before operators. 1033 1034 .. code-block:: c++ 1035 1036 LooooooooooongType loooooooooooooooooooooongVariable 1037 = someLooooooooooooooooongFunction(); 1038 1039 bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1040 + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1041 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1042 && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1043 > ccccccccccccccccccccccccccccccccccccccccc; 1044 1045 1046 1047**BreakBeforeBraces** (``BraceBreakingStyle``) 1048 The brace breaking style to use. 1049 1050 Possible values: 1051 1052 * ``BS_Attach`` (in configuration: ``Attach``) 1053 Always attach braces to surrounding context. 1054 1055 .. code-block:: c++ 1056 1057 try { 1058 foo(); 1059 } catch () { 1060 } 1061 void foo() { bar(); } 1062 class foo {}; 1063 if (foo()) { 1064 } else { 1065 } 1066 enum X : int { A, B }; 1067 1068 * ``BS_Linux`` (in configuration: ``Linux``) 1069 Like ``Attach``, but break before braces on function, namespace and 1070 class definitions. 1071 1072 .. code-block:: c++ 1073 1074 try { 1075 foo(); 1076 } catch () { 1077 } 1078 void foo() { bar(); } 1079 class foo 1080 { 1081 }; 1082 if (foo()) { 1083 } else { 1084 } 1085 enum X : int { A, B }; 1086 1087 * ``BS_Mozilla`` (in configuration: ``Mozilla``) 1088 Like ``Attach``, but break before braces on enum, function, and record 1089 definitions. 1090 1091 .. code-block:: c++ 1092 1093 try { 1094 foo(); 1095 } catch () { 1096 } 1097 void foo() { bar(); } 1098 class foo 1099 { 1100 }; 1101 if (foo()) { 1102 } else { 1103 } 1104 enum X : int { A, B }; 1105 1106 * ``BS_Stroustrup`` (in configuration: ``Stroustrup``) 1107 Like ``Attach``, but break before function definitions, ``catch``, and 1108 ``else``. 1109 1110 .. code-block:: c++ 1111 1112 try { 1113 foo(); 1114 } 1115 catch () { 1116 } 1117 void foo() { bar(); } 1118 class foo { 1119 }; 1120 if (foo()) { 1121 } 1122 else { 1123 } 1124 enum X : int { A, B }; 1125 1126 * ``BS_Allman`` (in configuration: ``Allman``) 1127 Always break before braces. 1128 1129 .. code-block:: c++ 1130 1131 try 1132 { 1133 foo(); 1134 } 1135 catch () 1136 { 1137 } 1138 void foo() { bar(); } 1139 class foo 1140 { 1141 }; 1142 if (foo()) 1143 { 1144 } 1145 else 1146 { 1147 } 1148 enum X : int 1149 { 1150 A, 1151 B 1152 }; 1153 1154 * ``BS_Whitesmiths`` (in configuration: ``Whitesmiths``) 1155 Like ``Allman`` but always indent braces and line up code with braces. 1156 1157 .. code-block:: c++ 1158 1159 try 1160 { 1161 foo(); 1162 } 1163 catch () 1164 { 1165 } 1166 void foo() { bar(); } 1167 class foo 1168 { 1169 }; 1170 if (foo()) 1171 { 1172 } 1173 else 1174 { 1175 } 1176 enum X : int 1177 { 1178 A, 1179 B 1180 }; 1181 1182 * ``BS_GNU`` (in configuration: ``GNU``) 1183 Always break before braces and add an extra level of indentation to 1184 braces of control statements, not to those of class, function 1185 or other definitions. 1186 1187 .. code-block:: c++ 1188 1189 try 1190 { 1191 foo(); 1192 } 1193 catch () 1194 { 1195 } 1196 void foo() { bar(); } 1197 class foo 1198 { 1199 }; 1200 if (foo()) 1201 { 1202 } 1203 else 1204 { 1205 } 1206 enum X : int 1207 { 1208 A, 1209 B 1210 }; 1211 1212 * ``BS_WebKit`` (in configuration: ``WebKit``) 1213 Like ``Attach``, but break before functions. 1214 1215 .. code-block:: c++ 1216 1217 try { 1218 foo(); 1219 } catch () { 1220 } 1221 void foo() { bar(); } 1222 class foo { 1223 }; 1224 if (foo()) { 1225 } else { 1226 } 1227 enum X : int { A, B }; 1228 1229 * ``BS_Custom`` (in configuration: ``Custom``) 1230 Configure each individual brace in `BraceWrapping`. 1231 1232 1233 1234**BreakBeforeTernaryOperators** (``bool``) 1235 If ``true``, ternary operators will be placed after line breaks. 1236 1237 .. code-block:: c++ 1238 1239 true: 1240 veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription 1241 ? firstValue 1242 : SecondValueVeryVeryVeryVeryLong; 1243 1244 false: 1245 veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ? 1246 firstValue : 1247 SecondValueVeryVeryVeryVeryLong; 1248 1249**BreakConstructorInitializers** (``BreakConstructorInitializersStyle``) 1250 The constructor initializers style to use. 1251 1252 Possible values: 1253 1254 * ``BCIS_BeforeColon`` (in configuration: ``BeforeColon``) 1255 Break constructor initializers before the colon and after the commas. 1256 1257 .. code-block:: c++ 1258 1259 Constructor() 1260 : initializer1(), 1261 initializer2() 1262 1263 * ``BCIS_BeforeComma`` (in configuration: ``BeforeComma``) 1264 Break constructor initializers before the colon and commas, and align 1265 the commas with the colon. 1266 1267 .. code-block:: c++ 1268 1269 Constructor() 1270 : initializer1() 1271 , initializer2() 1272 1273 * ``BCIS_AfterColon`` (in configuration: ``AfterColon``) 1274 Break constructor initializers after the colon and commas. 1275 1276 .. code-block:: c++ 1277 1278 Constructor() : 1279 initializer1(), 1280 initializer2() 1281 1282 1283 1284**BreakInheritanceList** (``BreakInheritanceListStyle``) 1285 The inheritance list style to use. 1286 1287 Possible values: 1288 1289 * ``BILS_BeforeColon`` (in configuration: ``BeforeColon``) 1290 Break inheritance list before the colon and after the commas. 1291 1292 .. code-block:: c++ 1293 1294 class Foo 1295 : Base1, 1296 Base2 1297 {}; 1298 1299 * ``BILS_BeforeComma`` (in configuration: ``BeforeComma``) 1300 Break inheritance list before the colon and commas, and align 1301 the commas with the colon. 1302 1303 .. code-block:: c++ 1304 1305 class Foo 1306 : Base1 1307 , Base2 1308 {}; 1309 1310 * ``BILS_AfterColon`` (in configuration: ``AfterColon``) 1311 Break inheritance list after the colon and commas. 1312 1313 .. code-block:: c++ 1314 1315 class Foo : 1316 Base1, 1317 Base2 1318 {}; 1319 1320 1321 1322**BreakStringLiterals** (``bool``) 1323 Allow breaking string literals when formatting. 1324 1325 .. code-block:: c++ 1326 1327 true: 1328 const char* x = "veryVeryVeryVeryVeryVe" 1329 "ryVeryVeryVeryVeryVery" 1330 "VeryLongString"; 1331 1332 false: 1333 const char* x = 1334 "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString"; 1335 1336**ColumnLimit** (``unsigned``) 1337 The column limit. 1338 1339 A column limit of ``0`` means that there is no column limit. In this case, 1340 clang-format will respect the input's line breaking decisions within 1341 statements unless they contradict other rules. 1342 1343**CommentPragmas** (``std::string``) 1344 A regular expression that describes comments with special meaning, 1345 which should not be split into lines or otherwise changed. 1346 1347 .. code-block:: c++ 1348 1349 // CommentPragmas: '^ FOOBAR pragma:' 1350 // Will leave the following line unaffected 1351 #include <vector> // FOOBAR pragma: keep 1352 1353**CompactNamespaces** (``bool``) 1354 If ``true``, consecutive namespace declarations will be on the same 1355 line. If ``false``, each namespace is declared on a new line. 1356 1357 .. code-block:: c++ 1358 1359 true: 1360 namespace Foo { namespace Bar { 1361 }} 1362 1363 false: 1364 namespace Foo { 1365 namespace Bar { 1366 } 1367 } 1368 1369 If it does not fit on a single line, the overflowing namespaces get 1370 wrapped: 1371 1372 .. code-block:: c++ 1373 1374 namespace Foo { namespace Bar { 1375 namespace Extra { 1376 }}} 1377 1378**ConstructorInitializerAllOnOneLineOrOnePerLine** (``bool``) 1379 If the constructor initializers don't fit on a line, put each 1380 initializer on its own line. 1381 1382 .. code-block:: c++ 1383 1384 true: 1385 SomeClass::Constructor() 1386 : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) { 1387 return 0; 1388 } 1389 1390 false: 1391 SomeClass::Constructor() 1392 : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), 1393 aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) { 1394 return 0; 1395 } 1396 1397**ConstructorInitializerIndentWidth** (``unsigned``) 1398 The number of characters to use for indentation of constructor 1399 initializer lists as well as inheritance lists. 1400 1401**ContinuationIndentWidth** (``unsigned``) 1402 Indent width for line continuations. 1403 1404 .. code-block:: c++ 1405 1406 ContinuationIndentWidth: 2 1407 1408 int i = // VeryVeryVeryVeryVeryLongComment 1409 longFunction( // Again a long comment 1410 arg); 1411 1412**Cpp11BracedListStyle** (``bool``) 1413 If ``true``, format braced lists as best suited for C++11 braced 1414 lists. 1415 1416 Important differences: 1417 - No spaces inside the braced list. 1418 - No line break before the closing brace. 1419 - Indentation with the continuation indent, not with the block indent. 1420 1421 Fundamentally, C++11 braced lists are formatted exactly like function 1422 calls would be formatted in their place. If the braced list follows a name 1423 (e.g. a type or variable name), clang-format formats as if the ``{}`` were 1424 the parentheses of a function call with that name. If there is no name, 1425 a zero-length name is assumed. 1426 1427 .. code-block:: c++ 1428 1429 true: false: 1430 vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 }; 1431 vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} }; 1432 f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]); 1433 new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 }; 1434 1435**DeriveLineEnding** (``bool``) 1436 Analyze the formatted file for the most used line ending (``\r\n`` 1437 or ``\n``). ``UseCRLF`` is only used as a fallback if none can be derived. 1438 1439**DerivePointerAlignment** (``bool``) 1440 If ``true``, analyze the formatted file for the most common 1441 alignment of ``&`` and ``*``. 1442 Pointer and reference alignment styles are going to be updated according 1443 to the preferences found in the file. 1444 ``PointerAlignment`` is then used only as fallback. 1445 1446**DisableFormat** (``bool``) 1447 Disables formatting completely. 1448 1449**ExperimentalAutoDetectBinPacking** (``bool``) 1450 If ``true``, clang-format detects whether function calls and 1451 definitions are formatted with one parameter per line. 1452 1453 Each call can be bin-packed, one-per-line or inconclusive. If it is 1454 inconclusive, e.g. completely on one line, but a decision needs to be 1455 made, clang-format analyzes whether there are other bin-packed cases in 1456 the input file and act accordingly. 1457 1458 NOTE: This is an experimental flag, that might go away or be renamed. Do 1459 not use this in config files, etc. Use at your own risk. 1460 1461**FixNamespaceComments** (``bool``) 1462 If ``true``, clang-format adds missing namespace end comments and 1463 fixes invalid existing ones. 1464 1465 .. code-block:: c++ 1466 1467 true: false: 1468 namespace a { vs. namespace a { 1469 foo(); foo(); 1470 } // namespace a } 1471 1472**ForEachMacros** (``std::vector<std::string>``) 1473 A vector of macros that should be interpreted as foreach loops 1474 instead of as function calls. 1475 1476 These are expected to be macros of the form: 1477 1478 .. code-block:: c++ 1479 1480 FOREACH(<variable-declaration>, ...) 1481 <loop-body> 1482 1483 In the .clang-format configuration file, this can be configured like: 1484 1485 .. code-block:: yaml 1486 1487 ForEachMacros: ['RANGES_FOR', 'FOREACH'] 1488 1489 For example: BOOST_FOREACH. 1490 1491**IncludeBlocks** (``IncludeBlocksStyle``) 1492 Dependent on the value, multiple ``#include`` blocks can be sorted 1493 as one and divided based on category. 1494 1495 Possible values: 1496 1497 * ``IBS_Preserve`` (in configuration: ``Preserve``) 1498 Sort each ``#include`` block separately. 1499 1500 .. code-block:: c++ 1501 1502 #include "b.h" into #include "b.h" 1503 1504 #include <lib/main.h> #include "a.h" 1505 #include "a.h" #include <lib/main.h> 1506 1507 * ``IBS_Merge`` (in configuration: ``Merge``) 1508 Merge multiple ``#include`` blocks together and sort as one. 1509 1510 .. code-block:: c++ 1511 1512 #include "b.h" into #include "a.h" 1513 #include "b.h" 1514 #include <lib/main.h> #include <lib/main.h> 1515 #include "a.h" 1516 1517 * ``IBS_Regroup`` (in configuration: ``Regroup``) 1518 Merge multiple ``#include`` blocks together and sort as one. 1519 Then split into groups based on category priority. See 1520 ``IncludeCategories``. 1521 1522 .. code-block:: c++ 1523 1524 #include "b.h" into #include "a.h" 1525 #include "b.h" 1526 #include <lib/main.h> 1527 #include "a.h" #include <lib/main.h> 1528 1529 1530 1531**IncludeCategories** (``std::vector<IncludeCategory>``) 1532 Regular expressions denoting the different ``#include`` categories 1533 used for ordering ``#includes``. 1534 1535 `POSIX extended 1536 <https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html>`_ 1537 regular expressions are supported. 1538 1539 These regular expressions are matched against the filename of an include 1540 (including the <> or "") in order. The value belonging to the first 1541 matching regular expression is assigned and ``#includes`` are sorted first 1542 according to increasing category number and then alphabetically within 1543 each category. 1544 1545 If none of the regular expressions match, INT_MAX is assigned as 1546 category. The main header for a source file automatically gets category 0. 1547 so that it is generally kept at the beginning of the ``#includes`` 1548 (https://llvm.org/docs/CodingStandards.html#include-style). However, you 1549 can also assign negative priorities if you have certain headers that 1550 always need to be first. 1551 1552 There is a third and optional field ``SortPriority`` which can used while 1553 ``IncludeBloks = IBS_Regroup`` to define the priority in which ``#includes`` 1554 should be ordered, and value of ``Priority`` defines the order of 1555 ``#include blocks`` and also enables to group ``#includes`` of different 1556 priority for order.``SortPriority`` is set to the value of ``Priority`` 1557 as default if it is not assigned. 1558 1559 To configure this in the .clang-format file, use: 1560 1561 .. code-block:: yaml 1562 1563 IncludeCategories: 1564 - Regex: '^"(llvm|llvm-c|clang|clang-c)/' 1565 Priority: 2 1566 SortPriority: 2 1567 - Regex: '^(<|"(gtest|gmock|isl|json)/)' 1568 Priority: 3 1569 - Regex: '<[[:alnum:].]+>' 1570 Priority: 4 1571 - Regex: '.*' 1572 Priority: 1 1573 SortPriority: 0 1574 1575**IncludeIsMainRegex** (``std::string``) 1576 Specify a regular expression of suffixes that are allowed in the 1577 file-to-main-include mapping. 1578 1579 When guessing whether a #include is the "main" include (to assign 1580 category 0, see above), use this regex of allowed suffixes to the header 1581 stem. A partial match is done, so that: 1582 - "" means "arbitrary suffix" 1583 - "$" means "no suffix" 1584 1585 For example, if configured to "(_test)?$", then a header a.h would be seen 1586 as the "main" include in both a.cc and a_test.cc. 1587 1588**IncludeIsMainSourceRegex** (``std::string``) 1589 Specify a regular expression for files being formatted 1590 that are allowed to be considered "main" in the 1591 file-to-main-include mapping. 1592 1593 By default, clang-format considers files as "main" only when they end 1594 with: ``.c``, ``.cc``, ``.cpp``, ``.c++``, ``.cxx``, ``.m`` or ``.mm`` 1595 extensions. 1596 For these files a guessing of "main" include takes place 1597 (to assign category 0, see above). This config option allows for 1598 additional suffixes and extensions for files to be considered as "main". 1599 1600 For example, if this option is configured to ``(Impl\.hpp)$``, 1601 then a file ``ClassImpl.hpp`` is considered "main" (in addition to 1602 ``Class.c``, ``Class.cc``, ``Class.cpp`` and so on) and "main 1603 include file" logic will be executed (with *IncludeIsMainRegex* setting 1604 also being respected in later phase). Without this option set, 1605 ``ClassImpl.hpp`` would not have the main include file put on top 1606 before any other include. 1607 1608**IndentCaseLabels** (``bool``) 1609 Indent case labels one level from the switch statement. 1610 1611 When ``false``, use the same indentation level as for the switch 1612 statement. Switch statement body is always indented one level more than 1613 case labels. 1614 1615 .. code-block:: c++ 1616 1617 false: true: 1618 switch (fool) { vs. switch (fool) { 1619 case 1: case 1: 1620 bar(); bar(); 1621 break; break; 1622 default: default: 1623 plop(); plop(); 1624 } } 1625 1626**IndentGotoLabels** (``bool``) 1627 Indent goto labels. 1628 1629 When ``false``, goto labels are flushed left. 1630 1631 .. code-block:: c++ 1632 1633 true: false: 1634 int f() { vs. int f() { 1635 if (foo()) { if (foo()) { 1636 label1: label1: 1637 bar(); bar(); 1638 } } 1639 label2: label2: 1640 return 1; return 1; 1641 } } 1642 1643**IndentPPDirectives** (``PPDirectiveIndentStyle``) 1644 The preprocessor directive indenting style to use. 1645 1646 Possible values: 1647 1648 * ``PPDIS_None`` (in configuration: ``None``) 1649 Does not indent any directives. 1650 1651 .. code-block:: c++ 1652 1653 #if FOO 1654 #if BAR 1655 #include <foo> 1656 #endif 1657 #endif 1658 1659 * ``PPDIS_AfterHash`` (in configuration: ``AfterHash``) 1660 Indents directives after the hash. 1661 1662 .. code-block:: c++ 1663 1664 #if FOO 1665 # if BAR 1666 # include <foo> 1667 # endif 1668 #endif 1669 1670 * ``PPDIS_BeforeHash`` (in configuration: ``BeforeHash``) 1671 Indents directives before the hash. 1672 1673 .. code-block:: c++ 1674 1675 #if FOO 1676 #if BAR 1677 #include <foo> 1678 #endif 1679 #endif 1680 1681 1682 1683**IndentWidth** (``unsigned``) 1684 The number of columns to use for indentation. 1685 1686 .. code-block:: c++ 1687 1688 IndentWidth: 3 1689 1690 void f() { 1691 someFunction(); 1692 if (true, false) { 1693 f(); 1694 } 1695 } 1696 1697**IndentWrappedFunctionNames** (``bool``) 1698 Indent if a function definition or declaration is wrapped after the 1699 type. 1700 1701 .. code-block:: c++ 1702 1703 true: 1704 LoooooooooooooooooooooooooooooooooooooooongReturnType 1705 LoooooooooooooooooooooooooooooooongFunctionDeclaration(); 1706 1707 false: 1708 LoooooooooooooooooooooooooooooooooooooooongReturnType 1709 LoooooooooooooooooooooooooooooooongFunctionDeclaration(); 1710 1711**JavaImportGroups** (``std::vector<std::string>``) 1712 A vector of prefixes ordered by the desired groups for Java imports. 1713 1714 Each group is separated by a newline. Static imports will also follow the 1715 same grouping convention above all non-static imports. One group's prefix 1716 can be a subset of another - the longest prefix is always matched. Within 1717 a group, the imports are ordered lexicographically. 1718 1719 In the .clang-format configuration file, this can be configured like 1720 in the following yaml example. This will result in imports being 1721 formatted as in the Java example below. 1722 1723 .. code-block:: yaml 1724 1725 JavaImportGroups: ['com.example', 'com', 'org'] 1726 1727 1728 .. code-block:: java 1729 1730 import static com.example.function1; 1731 1732 import static com.test.function2; 1733 1734 import static org.example.function3; 1735 1736 import com.example.ClassA; 1737 import com.example.Test; 1738 import com.example.a.ClassB; 1739 1740 import com.test.ClassC; 1741 1742 import org.example.ClassD; 1743 1744**JavaScriptQuotes** (``JavaScriptQuoteStyle``) 1745 The JavaScriptQuoteStyle to use for JavaScript strings. 1746 1747 Possible values: 1748 1749 * ``JSQS_Leave`` (in configuration: ``Leave``) 1750 Leave string quotes as they are. 1751 1752 .. code-block:: js 1753 1754 string1 = "foo"; 1755 string2 = 'bar'; 1756 1757 * ``JSQS_Single`` (in configuration: ``Single``) 1758 Always use single quotes. 1759 1760 .. code-block:: js 1761 1762 string1 = 'foo'; 1763 string2 = 'bar'; 1764 1765 * ``JSQS_Double`` (in configuration: ``Double``) 1766 Always use double quotes. 1767 1768 .. code-block:: js 1769 1770 string1 = "foo"; 1771 string2 = "bar"; 1772 1773 1774 1775**JavaScriptWrapImports** (``bool``) 1776 Whether to wrap JavaScript import/export statements. 1777 1778 .. code-block:: js 1779 1780 true: 1781 import { 1782 VeryLongImportsAreAnnoying, 1783 VeryLongImportsAreAnnoying, 1784 VeryLongImportsAreAnnoying, 1785 } from 'some/module.js' 1786 1787 false: 1788 import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js" 1789 1790**KeepEmptyLinesAtTheStartOfBlocks** (``bool``) 1791 If true, the empty line at the start of blocks is kept. 1792 1793 .. code-block:: c++ 1794 1795 true: false: 1796 if (foo) { vs. if (foo) { 1797 bar(); 1798 bar(); } 1799 } 1800 1801**Language** (``LanguageKind``) 1802 Language, this format style is targeted at. 1803 1804 Possible values: 1805 1806 * ``LK_None`` (in configuration: ``None``) 1807 Do not use. 1808 1809 * ``LK_Cpp`` (in configuration: ``Cpp``) 1810 Should be used for C, C++. 1811 1812 * ``LK_CSharp`` (in configuration: ``CSharp``) 1813 Should be used for C#. 1814 1815 * ``LK_Java`` (in configuration: ``Java``) 1816 Should be used for Java. 1817 1818 * ``LK_JavaScript`` (in configuration: ``JavaScript``) 1819 Should be used for JavaScript. 1820 1821 * ``LK_ObjC`` (in configuration: ``ObjC``) 1822 Should be used for Objective-C, Objective-C++. 1823 1824 * ``LK_Proto`` (in configuration: ``Proto``) 1825 Should be used for Protocol Buffers 1826 (https://developers.google.com/protocol-buffers/). 1827 1828 * ``LK_TableGen`` (in configuration: ``TableGen``) 1829 Should be used for TableGen code. 1830 1831 * ``LK_TextProto`` (in configuration: ``TextProto``) 1832 Should be used for Protocol Buffer messages in text format 1833 (https://developers.google.com/protocol-buffers/). 1834 1835 1836 1837**MacroBlockBegin** (``std::string``) 1838 A regular expression matching macros that start a block. 1839 1840 .. code-block:: c++ 1841 1842 # With: 1843 MacroBlockBegin: "^NS_MAP_BEGIN|\ 1844 NS_TABLE_HEAD$" 1845 MacroBlockEnd: "^\ 1846 NS_MAP_END|\ 1847 NS_TABLE_.*_END$" 1848 1849 NS_MAP_BEGIN 1850 foo(); 1851 NS_MAP_END 1852 1853 NS_TABLE_HEAD 1854 bar(); 1855 NS_TABLE_FOO_END 1856 1857 # Without: 1858 NS_MAP_BEGIN 1859 foo(); 1860 NS_MAP_END 1861 1862 NS_TABLE_HEAD 1863 bar(); 1864 NS_TABLE_FOO_END 1865 1866**MacroBlockEnd** (``std::string``) 1867 A regular expression matching macros that end a block. 1868 1869**MaxEmptyLinesToKeep** (``unsigned``) 1870 The maximum number of consecutive empty lines to keep. 1871 1872 .. code-block:: c++ 1873 1874 MaxEmptyLinesToKeep: 1 vs. MaxEmptyLinesToKeep: 0 1875 int f() { int f() { 1876 int = 1; int i = 1; 1877 i = foo(); 1878 i = foo(); return i; 1879 } 1880 return i; 1881 } 1882 1883**NamespaceIndentation** (``NamespaceIndentationKind``) 1884 The indentation used for namespaces. 1885 1886 Possible values: 1887 1888 * ``NI_None`` (in configuration: ``None``) 1889 Don't indent in namespaces. 1890 1891 .. code-block:: c++ 1892 1893 namespace out { 1894 int i; 1895 namespace in { 1896 int i; 1897 } 1898 } 1899 1900 * ``NI_Inner`` (in configuration: ``Inner``) 1901 Indent only in inner namespaces (nested in other namespaces). 1902 1903 .. code-block:: c++ 1904 1905 namespace out { 1906 int i; 1907 namespace in { 1908 int i; 1909 } 1910 } 1911 1912 * ``NI_All`` (in configuration: ``All``) 1913 Indent in all namespaces. 1914 1915 .. code-block:: c++ 1916 1917 namespace out { 1918 int i; 1919 namespace in { 1920 int i; 1921 } 1922 } 1923 1924 1925 1926**NamespaceMacros** (``std::vector<std::string>``) 1927 A vector of macros which are used to open namespace blocks. 1928 1929 These are expected to be macros of the form: 1930 1931 .. code-block:: c++ 1932 1933 NAMESPACE(<namespace-name>, ...) { 1934 <namespace-content> 1935 } 1936 1937 For example: TESTSUITE 1938 1939**ObjCBinPackProtocolList** (``BinPackStyle``) 1940 Controls bin-packing Objective-C protocol conformance list 1941 items into as few lines as possible when they go over ``ColumnLimit``. 1942 1943 If ``Auto`` (the default), delegates to the value in 1944 ``BinPackParameters``. If that is ``true``, bin-packs Objective-C 1945 protocol conformance list items into as few lines as possible 1946 whenever they go over ``ColumnLimit``. 1947 1948 If ``Always``, always bin-packs Objective-C protocol conformance 1949 list items into as few lines as possible whenever they go over 1950 ``ColumnLimit``. 1951 1952 If ``Never``, lays out Objective-C protocol conformance list items 1953 onto individual lines whenever they go over ``ColumnLimit``. 1954 1955 1956 .. code-block:: objc 1957 1958 Always (or Auto, if BinPackParameters=true): 1959 @interface ccccccccccccc () < 1960 ccccccccccccc, ccccccccccccc, 1961 ccccccccccccc, ccccccccccccc> { 1962 } 1963 1964 Never (or Auto, if BinPackParameters=false): 1965 @interface ddddddddddddd () < 1966 ddddddddddddd, 1967 ddddddddddddd, 1968 ddddddddddddd, 1969 ddddddddddddd> { 1970 } 1971 1972 Possible values: 1973 1974 * ``BPS_Auto`` (in configuration: ``Auto``) 1975 Automatically determine parameter bin-packing behavior. 1976 1977 * ``BPS_Always`` (in configuration: ``Always``) 1978 Always bin-pack parameters. 1979 1980 * ``BPS_Never`` (in configuration: ``Never``) 1981 Never bin-pack parameters. 1982 1983 1984 1985**ObjCBlockIndentWidth** (``unsigned``) 1986 The number of characters to use for indentation of ObjC blocks. 1987 1988 .. code-block:: objc 1989 1990 ObjCBlockIndentWidth: 4 1991 1992 [operation setCompletionBlock:^{ 1993 [self onOperationDone]; 1994 }]; 1995 1996**ObjCSpaceAfterProperty** (``bool``) 1997 Add a space after ``@property`` in Objective-C, i.e. use 1998 ``@property (readonly)`` instead of ``@property(readonly)``. 1999 2000**ObjCSpaceBeforeProtocolList** (``bool``) 2001 Add a space in front of an Objective-C protocol list, i.e. use 2002 ``Foo <Protocol>`` instead of ``Foo<Protocol>``. 2003 2004**PenaltyBreakAssignment** (``unsigned``) 2005 The penalty for breaking around an assignment operator. 2006 2007**PenaltyBreakBeforeFirstCallParameter** (``unsigned``) 2008 The penalty for breaking a function call after ``call(``. 2009 2010**PenaltyBreakComment** (``unsigned``) 2011 The penalty for each line break introduced inside a comment. 2012 2013**PenaltyBreakFirstLessLess** (``unsigned``) 2014 The penalty for breaking before the first ``<<``. 2015 2016**PenaltyBreakString** (``unsigned``) 2017 The penalty for each line break introduced inside a string literal. 2018 2019**PenaltyBreakTemplateDeclaration** (``unsigned``) 2020 The penalty for breaking after template declaration. 2021 2022**PenaltyExcessCharacter** (``unsigned``) 2023 The penalty for each character outside of the column limit. 2024 2025**PenaltyReturnTypeOnItsOwnLine** (``unsigned``) 2026 Penalty for putting the return type of a function onto its own 2027 line. 2028 2029**PointerAlignment** (``PointerAlignmentStyle``) 2030 Pointer and reference alignment style. 2031 2032 Possible values: 2033 2034 * ``PAS_Left`` (in configuration: ``Left``) 2035 Align pointer to the left. 2036 2037 .. code-block:: c++ 2038 2039 int* a; 2040 2041 * ``PAS_Right`` (in configuration: ``Right``) 2042 Align pointer to the right. 2043 2044 .. code-block:: c++ 2045 2046 int *a; 2047 2048 * ``PAS_Middle`` (in configuration: ``Middle``) 2049 Align pointer in the middle. 2050 2051 .. code-block:: c++ 2052 2053 int * a; 2054 2055 2056 2057**RawStringFormats** (``std::vector<RawStringFormat>``) 2058 Defines hints for detecting supported languages code blocks in raw 2059 strings. 2060 2061 A raw string with a matching delimiter or a matching enclosing function 2062 name will be reformatted assuming the specified language based on the 2063 style for that language defined in the .clang-format file. If no style has 2064 been defined in the .clang-format file for the specific language, a 2065 predefined style given by 'BasedOnStyle' is used. If 'BasedOnStyle' is not 2066 found, the formatting is based on llvm style. A matching delimiter takes 2067 precedence over a matching enclosing function name for determining the 2068 language of the raw string contents. 2069 2070 If a canonical delimiter is specified, occurrences of other delimiters for 2071 the same language will be updated to the canonical if possible. 2072 2073 There should be at most one specification per language and each delimiter 2074 and enclosing function should not occur in multiple specifications. 2075 2076 To configure this in the .clang-format file, use: 2077 2078 .. code-block:: yaml 2079 2080 RawStringFormats: 2081 - Language: TextProto 2082 Delimiters: 2083 - 'pb' 2084 - 'proto' 2085 EnclosingFunctions: 2086 - 'PARSE_TEXT_PROTO' 2087 BasedOnStyle: google 2088 - Language: Cpp 2089 Delimiters: 2090 - 'cc' 2091 - 'cpp' 2092 BasedOnStyle: llvm 2093 CanonicalDelimiter: 'cc' 2094 2095**ReflowComments** (``bool``) 2096 If ``true``, clang-format will attempt to re-flow comments. 2097 2098 .. code-block:: c++ 2099 2100 false: 2101 // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information 2102 /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */ 2103 2104 true: 2105 // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of 2106 // information 2107 /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of 2108 * information */ 2109 2110**SortIncludes** (``bool``) 2111 If ``true``, clang-format will sort ``#includes``. 2112 2113 .. code-block:: c++ 2114 2115 false: true: 2116 #include "b.h" vs. #include "a.h" 2117 #include "a.h" #include "b.h" 2118 2119**SortUsingDeclarations** (``bool``) 2120 If ``true``, clang-format will sort using declarations. 2121 2122 The order of using declarations is defined as follows: 2123 Split the strings by "::" and discard any initial empty strings. The last 2124 element of each list is a non-namespace name; all others are namespace 2125 names. Sort the lists of names lexicographically, where the sort order of 2126 individual names is that all non-namespace names come before all namespace 2127 names, and within those groups, names are in case-insensitive 2128 lexicographic order. 2129 2130 .. code-block:: c++ 2131 2132 false: true: 2133 using std::cout; vs. using std::cin; 2134 using std::cin; using std::cout; 2135 2136**SpaceAfterCStyleCast** (``bool``) 2137 If ``true``, a space is inserted after C style casts. 2138 2139 .. code-block:: c++ 2140 2141 true: false: 2142 (int) i; vs. (int)i; 2143 2144**SpaceAfterLogicalNot** (``bool``) 2145 If ``true``, a space is inserted after the logical not operator (``!``). 2146 2147 .. code-block:: c++ 2148 2149 true: false: 2150 ! someExpression(); vs. !someExpression(); 2151 2152**SpaceAfterTemplateKeyword** (``bool``) 2153 If ``true``, a space will be inserted after the 'template' keyword. 2154 2155 .. code-block:: c++ 2156 2157 true: false: 2158 template <int> void foo(); vs. template<int> void foo(); 2159 2160**SpaceBeforeAssignmentOperators** (``bool``) 2161 If ``false``, spaces will be removed before assignment operators. 2162 2163 .. code-block:: c++ 2164 2165 true: false: 2166 int a = 5; vs. int a= 5; 2167 a += 42; a+= 42; 2168 2169**SpaceBeforeCpp11BracedList** (``bool``) 2170 If ``true``, a space will be inserted before a C++11 braced list 2171 used to initialize an object (after the preceding identifier or type). 2172 2173 .. code-block:: c++ 2174 2175 true: false: 2176 Foo foo { bar }; vs. Foo foo{ bar }; 2177 Foo {}; Foo{}; 2178 vector<int> { 1, 2, 3 }; vector<int>{ 1, 2, 3 }; 2179 new int[3] { 1, 2, 3 }; new int[3]{ 1, 2, 3 }; 2180 2181**SpaceBeforeCtorInitializerColon** (``bool``) 2182 If ``false``, spaces will be removed before constructor initializer 2183 colon. 2184 2185 .. code-block:: c++ 2186 2187 true: false: 2188 Foo::Foo() : a(a) {} Foo::Foo(): a(a) {} 2189 2190**SpaceBeforeInheritanceColon** (``bool``) 2191 If ``false``, spaces will be removed before inheritance colon. 2192 2193 .. code-block:: c++ 2194 2195 true: false: 2196 class Foo : Bar {} vs. class Foo: Bar {} 2197 2198**SpaceBeforeParens** (``SpaceBeforeParensOptions``) 2199 Defines in which cases to put a space before opening parentheses. 2200 2201 Possible values: 2202 2203 * ``SBPO_Never`` (in configuration: ``Never``) 2204 Never put a space before opening parentheses. 2205 2206 .. code-block:: c++ 2207 2208 void f() { 2209 if(true) { 2210 f(); 2211 } 2212 } 2213 2214 * ``SBPO_ControlStatements`` (in configuration: ``ControlStatements``) 2215 Put a space before opening parentheses only after control statement 2216 keywords (``for/if/while...``). 2217 2218 .. code-block:: c++ 2219 2220 void f() { 2221 if (true) { 2222 f(); 2223 } 2224 } 2225 2226 * ``SBPO_NonEmptyParentheses`` (in configuration: ``NonEmptyParentheses``) 2227 Put a space before opening parentheses only if the parentheses are not 2228 empty i.e. '()' 2229 2230 .. code-block:: c++ 2231 2232 void() { 2233 if (true) { 2234 f(); 2235 g (x, y, z); 2236 } 2237 } 2238 2239 * ``SBPO_Always`` (in configuration: ``Always``) 2240 Always put a space before opening parentheses, except when it's 2241 prohibited by the syntax rules (in function-like macro definitions) or 2242 when determined by other style rules (after unary operators, opening 2243 parentheses, etc.) 2244 2245 .. code-block:: c++ 2246 2247 void f () { 2248 if (true) { 2249 f (); 2250 } 2251 } 2252 2253 2254 2255**SpaceBeforeRangeBasedForLoopColon** (``bool``) 2256 If ``false``, spaces will be removed before range-based for loop 2257 colon. 2258 2259 .. code-block:: c++ 2260 2261 true: false: 2262 for (auto v : values) {} vs. for(auto v: values) {} 2263 2264**SpaceBeforeSquareBrackets** (``bool``) 2265 If ``true``, spaces will be before ``[``. 2266 Lambdas will not be affected. Only the first ``[`` will get a space added. 2267 2268 .. code-block:: c++ 2269 2270 true: false: 2271 int a [5]; vs. int a[5]; 2272 int a [5][5]; vs. int a[5][5]; 2273 2274**SpaceInEmptyBlock** (``bool``) 2275 If ``true``, spaces will be inserted into ``{}``. 2276 2277 .. code-block:: c++ 2278 2279 true: false: 2280 void f() { } vs. void f() {} 2281 while (true) { } while (true) {} 2282 2283**SpaceInEmptyParentheses** (``bool``) 2284 If ``true``, spaces may be inserted into ``()``. 2285 2286 .. code-block:: c++ 2287 2288 true: false: 2289 void f( ) { vs. void f() { 2290 int x[] = {foo( ), bar( )}; int x[] = {foo(), bar()}; 2291 if (true) { if (true) { 2292 f( ); f(); 2293 } } 2294 } } 2295 2296**SpacesBeforeTrailingComments** (``unsigned``) 2297 The number of spaces before trailing line comments 2298 (``//`` - comments). 2299 2300 This does not affect trailing block comments (``/*`` - comments) as 2301 those commonly have different usage patterns and a number of special 2302 cases. 2303 2304 .. code-block:: c++ 2305 2306 SpacesBeforeTrailingComments: 3 2307 void f() { 2308 if (true) { // foo1 2309 f(); // bar 2310 } // foo 2311 } 2312 2313**SpacesInAngles** (``bool``) 2314 If ``true``, spaces will be inserted after ``<`` and before ``>`` 2315 in template argument lists. 2316 2317 .. code-block:: c++ 2318 2319 true: false: 2320 static_cast< int >(arg); vs. static_cast<int>(arg); 2321 std::function< void(int) > fct; std::function<void(int)> fct; 2322 2323**SpacesInCStyleCastParentheses** (``bool``) 2324 If ``true``, spaces may be inserted into C style casts. 2325 2326 .. code-block:: c++ 2327 2328 true: false: 2329 x = ( int32 )y vs. x = (int32)y 2330 2331**SpacesInConditionalStatement** (``bool``) 2332 If ``true``, spaces will be inserted around if/for/while (and similar) conditions. 2333 2334**SpacesInContainerLiterals** (``bool``) 2335 If ``true``, spaces are inserted inside container literals (e.g. 2336 ObjC and Javascript array and dict literals). 2337 2338 .. code-block:: js 2339 2340 true: false: 2341 var arr = [ 1, 2, 3 ]; vs. var arr = [1, 2, 3]; 2342 f({a : 1, b : 2, c : 3}); f({a: 1, b: 2, c: 3}); 2343 2344**SpacesInParentheses** (``bool``) 2345 If ``true``, spaces will be inserted after ``(`` and before ``)``. 2346 2347 .. code-block:: c++ 2348 2349 true: false: 2350 t f( Deleted & ) & = delete; vs. t f(Deleted &) & = delete; 2351 2352**SpacesInSquareBrackets** (``bool``) 2353 If ``true``, spaces will be inserted after ``[`` and before ``]``. 2354 Lambdas without arguments or unspecified size array declarations will not 2355 be affected. 2356 2357 .. code-block:: c++ 2358 2359 true: false: 2360 int a[ 5 ]; vs. int a[5]; 2361 std::unique_ptr<int[]> foo() {} // Won't be affected 2362 2363**Standard** (``LanguageStandard``) 2364 Parse and format C++ constructs compatible with this standard. 2365 2366 .. code-block:: c++ 2367 2368 c++03: latest: 2369 vector<set<int> > x; vs. vector<set<int>> x; 2370 2371 Possible values: 2372 2373 * ``LS_Cpp03`` (in configuration: ``c++03``) 2374 Parse and format as C++03. 2375 ``Cpp03`` is a deprecated alias for ``c++03`` 2376 2377 * ``LS_Cpp11`` (in configuration: ``c++11``) 2378 Parse and format as C++11. 2379 2380 * ``LS_Cpp14`` (in configuration: ``c++14``) 2381 Parse and format as C++14. 2382 2383 * ``LS_Cpp17`` (in configuration: ``c++17``) 2384 Parse and format as C++17. 2385 2386 * ``LS_Cpp20`` (in configuration: ``c++20``) 2387 Parse and format as C++20. 2388 2389 * ``LS_Latest`` (in configuration: ``Latest``) 2390 Parse and format using the latest supported language version. 2391 ``Cpp11`` is a deprecated alias for ``Latest`` 2392 2393 * ``LS_Auto`` (in configuration: ``Auto``) 2394 Automatic detection based on the input. 2395 2396 2397 2398**StatementMacros** (``std::vector<std::string>``) 2399 A vector of macros that should be interpreted as complete 2400 statements. 2401 2402 Typical macros are expressions, and require a semi-colon to be 2403 added; sometimes this is not the case, and this allows to make 2404 clang-format aware of such cases. 2405 2406 For example: Q_UNUSED 2407 2408**TabWidth** (``unsigned``) 2409 The number of columns used for tab stops. 2410 2411**TypenameMacros** (``std::vector<std::string>``) 2412 A vector of macros that should be interpreted as type declarations 2413 instead of as function calls. 2414 2415 These are expected to be macros of the form: 2416 2417 .. code-block:: c++ 2418 2419 STACK_OF(...) 2420 2421 In the .clang-format configuration file, this can be configured like: 2422 2423 .. code-block:: yaml 2424 2425 TypenameMacros: ['STACK_OF', 'LIST'] 2426 2427 For example: OpenSSL STACK_OF, BSD LIST_ENTRY. 2428 2429**UseCRLF** (``bool``) 2430 Use ``\r\n`` instead of ``\n`` for line breaks. 2431 Also used as fallback if ``DeriveLineEnding`` is true. 2432 2433**UseTab** (``UseTabStyle``) 2434 The way to use tab characters in the resulting file. 2435 2436 Possible values: 2437 2438 * ``UT_Never`` (in configuration: ``Never``) 2439 Never use tab. 2440 2441 * ``UT_ForIndentation`` (in configuration: ``ForIndentation``) 2442 Use tabs only for indentation. 2443 2444 * ``UT_ForContinuationAndIndentation`` (in configuration: ``ForContinuationAndIndentation``) 2445 Use tabs only for line continuation and indentation. 2446 2447 * ``UT_Always`` (in configuration: ``Always``) 2448 Use tabs whenever we need to fill whitespace that spans at least from 2449 one tab stop to the next one. 2450 2451 2452 2453.. END_FORMAT_STYLE_OPTIONS 2454 2455Adding additional style options 2456=============================== 2457 2458Each additional style option adds costs to the clang-format project. Some of 2459these costs affect the clang-format development itself, as we need to make 2460sure that any given combination of options work and that new features don't 2461break any of the existing options in any way. There are also costs for end users 2462as options become less discoverable and people have to think about and make a 2463decision on options they don't really care about. 2464 2465The goal of the clang-format project is more on the side of supporting a 2466limited set of styles really well as opposed to supporting every single style 2467used by a codebase somewhere in the wild. Of course, we do want to support all 2468major projects and thus have established the following bar for adding style 2469options. Each new style option must .. 2470 2471 * be used in a project of significant size (have dozens of contributors) 2472 * have a publicly accessible style guide 2473 * have a person willing to contribute and maintain patches 2474 2475Examples 2476======== 2477 2478A style similar to the `Linux Kernel style 2479<https://www.kernel.org/doc/Documentation/CodingStyle>`_: 2480 2481.. code-block:: yaml 2482 2483 BasedOnStyle: LLVM 2484 IndentWidth: 8 2485 UseTab: Always 2486 BreakBeforeBraces: Linux 2487 AllowShortIfStatementsOnASingleLine: false 2488 IndentCaseLabels: false 2489 2490The result is (imagine that tabs are used for indentation here): 2491 2492.. code-block:: c++ 2493 2494 void test() 2495 { 2496 switch (x) { 2497 case 0: 2498 case 1: 2499 do_something(); 2500 break; 2501 case 2: 2502 do_something_else(); 2503 break; 2504 default: 2505 break; 2506 } 2507 if (condition) 2508 do_something_completely_different(); 2509 2510 if (x == y) { 2511 q(); 2512 } else if (x > y) { 2513 w(); 2514 } else { 2515 r(); 2516 } 2517 } 2518 2519A style similar to the default Visual Studio formatting style: 2520 2521.. code-block:: yaml 2522 2523 UseTab: Never 2524 IndentWidth: 4 2525 BreakBeforeBraces: Allman 2526 AllowShortIfStatementsOnASingleLine: false 2527 IndentCaseLabels: false 2528 ColumnLimit: 0 2529 2530The result is: 2531 2532.. code-block:: c++ 2533 2534 void test() 2535 { 2536 switch (suffix) 2537 { 2538 case 0: 2539 case 1: 2540 do_something(); 2541 break; 2542 case 2: 2543 do_something_else(); 2544 break; 2545 default: 2546 break; 2547 } 2548 if (condition) 2549 do_somthing_completely_different(); 2550 2551 if (x == y) 2552 { 2553 q(); 2554 } 2555 else if (x > y) 2556 { 2557 w(); 2558 } 2559 else 2560 { 2561 r(); 2562 } 2563 } 2564