1//===--- Format.h - Format C++ code -----------------------------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8/// 9/// \file 10/// Various functions to configurably format source code. 11/// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CLANG_FORMAT_FORMAT_H 15#define LLVM_CLANG_FORMAT_FORMAT_H 16 17#include "clang/Basic/LangOptions.h" 18#include "clang/Tooling/Core/Replacement.h" 19#include "clang/Tooling/Inclusions/IncludeStyle.h" 20#include "llvm/ADT/ArrayRef.h" 21#include "llvm/Support/Regex.h" 22#include "llvm/Support/SourceMgr.h" 23#include <optional> 24#include <system_error> 25 26namespace llvm { 27namespace vfs { 28class FileSystem; 29} 30} // namespace llvm 31 32namespace clang { 33namespace format { 34 35enum class ParseError { 36 Success = 0, 37 Error, 38 Unsuitable, 39 BinPackTrailingCommaConflict, 40 InvalidQualifierSpecified, 41 DuplicateQualifierSpecified, 42 MissingQualifierType, 43 MissingQualifierOrder 44}; 45class ParseErrorCategory final : public std::error_category { 46public: 47 const char *name() const noexcept override; 48 std::string message(int EV) const override; 49}; 50const std::error_category &getParseCategory(); 51std::error_code make_error_code(ParseError e); 52 53/// The ``FormatStyle`` is used to configure the formatting to follow 54/// specific guidelines. 55struct FormatStyle { 56 // If the BasedOn: was InheritParentConfig and this style needs the file from 57 // the parent directories. It is not part of the actual style for formatting. 58 // Thus the // instead of ///. 59 bool InheritsParentConfig; 60 61 /// The extra indent or outdent of access modifiers, e.g. ``public:``. 62 /// \version 3.3 63 int AccessModifierOffset; 64 65 /// Different styles for aligning after open brackets. 66 enum BracketAlignmentStyle : int8_t { 67 /// Align parameters on the open bracket, e.g.: 68 /// \code 69 /// someLongFunction(argument1, 70 /// argument2); 71 /// \endcode 72 BAS_Align, 73 /// Don't align, instead use ``ContinuationIndentWidth``, e.g.: 74 /// \code 75 /// someLongFunction(argument1, 76 /// argument2); 77 /// \endcode 78 BAS_DontAlign, 79 /// Always break after an open bracket, if the parameters don't fit 80 /// on a single line, e.g.: 81 /// \code 82 /// someLongFunction( 83 /// argument1, argument2); 84 /// \endcode 85 BAS_AlwaysBreak, 86 /// Always break after an open bracket, if the parameters don't fit 87 /// on a single line. Closing brackets will be placed on a new line. 88 /// E.g.: 89 /// \code 90 /// someLongFunction( 91 /// argument1, argument2 92 /// ) 93 /// \endcode 94 /// 95 /// \note 96 /// This currently only applies to braced initializer lists (when 97 /// ``Cpp11BracedListStyle`` is ``true``) and parentheses. 98 /// \endnote 99 BAS_BlockIndent, 100 }; 101 102 /// If ``true``, horizontally aligns arguments after an open bracket. 103 /// 104 /// This applies to round brackets (parentheses), angle brackets and square 105 /// brackets. 106 /// \version 3.8 107 BracketAlignmentStyle AlignAfterOpenBracket; 108 109 /// Different style for aligning array initializers. 110 enum ArrayInitializerAlignmentStyle : int8_t { 111 /// Align array column and left justify the columns e.g.: 112 /// \code 113 /// struct test demo[] = 114 /// { 115 /// {56, 23, "hello"}, 116 /// {-1, 93463, "world"}, 117 /// {7, 5, "!!" } 118 /// }; 119 /// \endcode 120 AIAS_Left, 121 /// Align array column and right justify the columns e.g.: 122 /// \code 123 /// struct test demo[] = 124 /// { 125 /// {56, 23, "hello"}, 126 /// {-1, 93463, "world"}, 127 /// { 7, 5, "!!"} 128 /// }; 129 /// \endcode 130 AIAS_Right, 131 /// Don't align array initializer columns. 132 AIAS_None 133 }; 134 /// if not ``None``, when using initialization for an array of structs 135 /// aligns the fields into columns. 136 /// 137 /// \note 138 /// As of clang-format 15 this option only applied to arrays with equal 139 /// number of columns per row. 140 /// \endnote 141 /// 142 /// \version 13 143 ArrayInitializerAlignmentStyle AlignArrayOfStructures; 144 145 /// Alignment options. 146 /// 147 /// They can also be read as a whole for compatibility. The choices are: 148 /// - None 149 /// - Consecutive 150 /// - AcrossEmptyLines 151 /// - AcrossComments 152 /// - AcrossEmptyLinesAndComments 153 /// 154 /// For example, to align across empty lines and not across comments, either 155 /// of these work. 156 /// \code 157 /// AlignConsecutiveMacros: AcrossEmptyLines 158 /// 159 /// AlignConsecutiveMacros: 160 /// Enabled: true 161 /// AcrossEmptyLines: true 162 /// AcrossComments: false 163 /// \endcode 164 struct AlignConsecutiveStyle { 165 /// Whether aligning is enabled. 166 /// \code 167 /// #define SHORT_NAME 42 168 /// #define LONGER_NAME 0x007f 169 /// #define EVEN_LONGER_NAME (2) 170 /// #define foo(x) (x * x) 171 /// #define bar(y, z) (y + z) 172 /// 173 /// int a = 1; 174 /// int somelongname = 2; 175 /// double c = 3; 176 /// 177 /// int aaaa : 1; 178 /// int b : 12; 179 /// int ccc : 8; 180 /// 181 /// int aaaa = 12; 182 /// float b = 23; 183 /// std::string ccc; 184 /// \endcode 185 bool Enabled; 186 /// Whether to align across empty lines. 187 /// \code 188 /// true: 189 /// int a = 1; 190 /// int somelongname = 2; 191 /// double c = 3; 192 /// 193 /// int d = 3; 194 /// 195 /// false: 196 /// int a = 1; 197 /// int somelongname = 2; 198 /// double c = 3; 199 /// 200 /// int d = 3; 201 /// \endcode 202 bool AcrossEmptyLines; 203 /// Whether to align across comments. 204 /// \code 205 /// true: 206 /// int d = 3; 207 /// /* A comment. */ 208 /// double e = 4; 209 /// 210 /// false: 211 /// int d = 3; 212 /// /* A comment. */ 213 /// double e = 4; 214 /// \endcode 215 bool AcrossComments; 216 /// Only for ``AlignConsecutiveAssignments``. Whether compound assignments 217 /// like ``+=`` are aligned along with ``=``. 218 /// \code 219 /// true: 220 /// a &= 2; 221 /// bbb = 2; 222 /// 223 /// false: 224 /// a &= 2; 225 /// bbb = 2; 226 /// \endcode 227 bool AlignCompound; 228 /// Only for ``AlignConsecutiveDeclarations``. Whether function pointers are 229 /// aligned. 230 /// \code 231 /// true: 232 /// unsigned i; 233 /// int &r; 234 /// int *p; 235 /// int (*f)(); 236 /// 237 /// false: 238 /// unsigned i; 239 /// int &r; 240 /// int *p; 241 /// int (*f)(); 242 /// \endcode 243 bool AlignFunctionPointers; 244 /// Only for ``AlignConsecutiveAssignments``. Whether short assignment 245 /// operators are left-padded to the same length as long ones in order to 246 /// put all assignment operators to the right of the left hand side. 247 /// \code 248 /// true: 249 /// a >>= 2; 250 /// bbb = 2; 251 /// 252 /// a = 2; 253 /// bbb >>= 2; 254 /// 255 /// false: 256 /// a >>= 2; 257 /// bbb = 2; 258 /// 259 /// a = 2; 260 /// bbb >>= 2; 261 /// \endcode 262 bool PadOperators; 263 bool operator==(const AlignConsecutiveStyle &R) const { 264 return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines && 265 AcrossComments == R.AcrossComments && 266 AlignCompound == R.AlignCompound && 267 AlignFunctionPointers == R.AlignFunctionPointers && 268 PadOperators == R.PadOperators; 269 } 270 bool operator!=(const AlignConsecutiveStyle &R) const { 271 return !(*this == R); 272 } 273 }; 274 275 /// Style of aligning consecutive macro definitions. 276 /// 277 /// ``Consecutive`` will result in formattings like: 278 /// \code 279 /// #define SHORT_NAME 42 280 /// #define LONGER_NAME 0x007f 281 /// #define EVEN_LONGER_NAME (2) 282 /// #define foo(x) (x * x) 283 /// #define bar(y, z) (y + z) 284 /// \endcode 285 /// \version 9 286 AlignConsecutiveStyle AlignConsecutiveMacros; 287 /// Style of aligning consecutive assignments. 288 /// 289 /// ``Consecutive`` will result in formattings like: 290 /// \code 291 /// int a = 1; 292 /// int somelongname = 2; 293 /// double c = 3; 294 /// \endcode 295 /// \version 3.8 296 AlignConsecutiveStyle AlignConsecutiveAssignments; 297 /// Style of aligning consecutive bit fields. 298 /// 299 /// ``Consecutive`` will align the bitfield separators of consecutive lines. 300 /// This will result in formattings like: 301 /// \code 302 /// int aaaa : 1; 303 /// int b : 12; 304 /// int ccc : 8; 305 /// \endcode 306 /// \version 11 307 AlignConsecutiveStyle AlignConsecutiveBitFields; 308 /// Style of aligning consecutive declarations. 309 /// 310 /// ``Consecutive`` will align the declaration names of consecutive lines. 311 /// This will result in formattings like: 312 /// \code 313 /// int aaaa = 12; 314 /// float b = 23; 315 /// std::string ccc; 316 /// \endcode 317 /// \version 3.8 318 AlignConsecutiveStyle AlignConsecutiveDeclarations; 319 320 /// Alignment options. 321 /// 322 struct ShortCaseStatementsAlignmentStyle { 323 /// Whether aligning is enabled. 324 /// \code 325 /// true: 326 /// switch (level) { 327 /// case log::info: return "info:"; 328 /// case log::warning: return "warning:"; 329 /// default: return ""; 330 /// } 331 /// 332 /// false: 333 /// switch (level) { 334 /// case log::info: return "info:"; 335 /// case log::warning: return "warning:"; 336 /// default: return ""; 337 /// } 338 /// \endcode 339 bool Enabled; 340 /// Whether to align across empty lines. 341 /// \code 342 /// true: 343 /// switch (level) { 344 /// case log::info: return "info:"; 345 /// case log::warning: return "warning:"; 346 /// 347 /// default: return ""; 348 /// } 349 /// 350 /// false: 351 /// switch (level) { 352 /// case log::info: return "info:"; 353 /// case log::warning: return "warning:"; 354 /// 355 /// default: return ""; 356 /// } 357 /// \endcode 358 bool AcrossEmptyLines; 359 /// Whether to align across comments. 360 /// \code 361 /// true: 362 /// switch (level) { 363 /// case log::info: return "info:"; 364 /// case log::warning: return "warning:"; 365 /// /* A comment. */ 366 /// default: return ""; 367 /// } 368 /// 369 /// false: 370 /// switch (level) { 371 /// case log::info: return "info:"; 372 /// case log::warning: return "warning:"; 373 /// /* A comment. */ 374 /// default: return ""; 375 /// } 376 /// \endcode 377 bool AcrossComments; 378 /// Whether aligned case labels are aligned on the colon, or on the 379 /// , or on the tokens after the colon. 380 /// \code 381 /// true: 382 /// switch (level) { 383 /// case log::info : return "info:"; 384 /// case log::warning: return "warning:"; 385 /// default : return ""; 386 /// } 387 /// 388 /// false: 389 /// switch (level) { 390 /// case log::info: return "info:"; 391 /// case log::warning: return "warning:"; 392 /// default: return ""; 393 /// } 394 /// \endcode 395 bool AlignCaseColons; 396 bool operator==(const ShortCaseStatementsAlignmentStyle &R) const { 397 return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines && 398 AcrossComments == R.AcrossComments && 399 AlignCaseColons == R.AlignCaseColons; 400 } 401 }; 402 403 /// Style of aligning consecutive short case labels. 404 /// Only applies if ``AllowShortCaseLabelsOnASingleLine`` is ``true``. 405 /// 406 /// \code{.yaml} 407 /// # Example of usage: 408 /// AlignConsecutiveShortCaseStatements: 409 /// Enabled: true 410 /// AcrossEmptyLines: true 411 /// AcrossComments: true 412 /// AlignCaseColons: false 413 /// \endcode 414 /// \version 17 415 ShortCaseStatementsAlignmentStyle AlignConsecutiveShortCaseStatements; 416 417 /// Different styles for aligning escaped newlines. 418 enum EscapedNewlineAlignmentStyle : int8_t { 419 /// Don't align escaped newlines. 420 /// \code 421 /// #define A \ 422 /// int aaaa; \ 423 /// int b; \ 424 /// int dddddddddd; 425 /// \endcode 426 ENAS_DontAlign, 427 /// Align escaped newlines as far left as possible. 428 /// \code 429 /// true: 430 /// #define A \ 431 /// int aaaa; \ 432 /// int b; \ 433 /// int dddddddddd; 434 /// 435 /// false: 436 /// \endcode 437 ENAS_Left, 438 /// Align escaped newlines in the right-most column. 439 /// \code 440 /// #define A \ 441 /// int aaaa; \ 442 /// int b; \ 443 /// int dddddddddd; 444 /// \endcode 445 ENAS_Right, 446 }; 447 448 /// Options for aligning backslashes in escaped newlines. 449 /// \version 5 450 EscapedNewlineAlignmentStyle AlignEscapedNewlines; 451 452 /// Different styles for aligning operands. 453 enum OperandAlignmentStyle : int8_t { 454 /// Do not align operands of binary and ternary expressions. 455 /// The wrapped lines are indented ``ContinuationIndentWidth`` spaces from 456 /// the start of the line. 457 OAS_DontAlign, 458 /// Horizontally align operands of binary and ternary expressions. 459 /// 460 /// Specifically, this aligns operands of a single expression that needs 461 /// to be split over multiple lines, e.g.: 462 /// \code 463 /// int aaa = bbbbbbbbbbbbbbb + 464 /// ccccccccccccccc; 465 /// \endcode 466 /// 467 /// When ``BreakBeforeBinaryOperators`` is set, the wrapped operator is 468 /// aligned with the operand on the first line. 469 /// \code 470 /// int aaa = bbbbbbbbbbbbbbb 471 /// + ccccccccccccccc; 472 /// \endcode 473 OAS_Align, 474 /// Horizontally align operands of binary and ternary expressions. 475 /// 476 /// This is similar to ``AO_Align``, except when 477 /// ``BreakBeforeBinaryOperators`` is set, the operator is un-indented so 478 /// that the wrapped operand is aligned with the operand on the first line. 479 /// \code 480 /// int aaa = bbbbbbbbbbbbbbb 481 /// + ccccccccccccccc; 482 /// \endcode 483 OAS_AlignAfterOperator, 484 }; 485 486 /// If ``true``, horizontally align operands of binary and ternary 487 /// expressions. 488 /// \version 3.5 489 OperandAlignmentStyle AlignOperands; 490 491 /// Enums for AlignTrailingComments 492 enum TrailingCommentsAlignmentKinds : int8_t { 493 /// Leave trailing comments as they are. 494 /// \code 495 /// int a; // comment 496 /// int ab; // comment 497 /// 498 /// int abc; // comment 499 /// int abcd; // comment 500 /// \endcode 501 TCAS_Leave, 502 /// Align trailing comments. 503 /// \code 504 /// int a; // comment 505 /// int ab; // comment 506 /// 507 /// int abc; // comment 508 /// int abcd; // comment 509 /// \endcode 510 TCAS_Always, 511 /// Don't align trailing comments but other formatter applies. 512 /// \code 513 /// int a; // comment 514 /// int ab; // comment 515 /// 516 /// int abc; // comment 517 /// int abcd; // comment 518 /// \endcode 519 TCAS_Never, 520 }; 521 522 /// Alignment options 523 struct TrailingCommentsAlignmentStyle { 524 /// Specifies the way to align trailing comments. 525 TrailingCommentsAlignmentKinds Kind; 526 /// How many empty lines to apply alignment. 527 /// When both ``MaxEmptyLinesToKeep`` and ``OverEmptyLines`` are set to 2, 528 /// it formats like below. 529 /// \code 530 /// int a; // all these 531 /// 532 /// int ab; // comments are 533 /// 534 /// 535 /// int abcdef; // aligned 536 /// \endcode 537 /// 538 /// When ``MaxEmptyLinesToKeep`` is set to 2 and ``OverEmptyLines`` is set 539 /// to 1, it formats like below. 540 /// \code 541 /// int a; // these are 542 /// 543 /// int ab; // aligned 544 /// 545 /// 546 /// int abcdef; // but this isn't 547 /// \endcode 548 unsigned OverEmptyLines; 549 550 bool operator==(const TrailingCommentsAlignmentStyle &R) const { 551 return Kind == R.Kind && OverEmptyLines == R.OverEmptyLines; 552 } 553 bool operator!=(const TrailingCommentsAlignmentStyle &R) const { 554 return !(*this == R); 555 } 556 }; 557 558 /// Control of trailing comments. 559 /// 560 /// The alignment stops at closing braces after a line break, and only 561 /// followed by other closing braces, a (``do-``) ``while``, a lambda call, or 562 /// a semicolon. 563 /// 564 /// \note 565 /// As of clang-format 16 this option is not a bool but can be set 566 /// to the options. Conventional bool options still can be parsed as before. 567 /// \endnote 568 /// 569 /// \code{.yaml} 570 /// # Example of usage: 571 /// AlignTrailingComments: 572 /// Kind: Always 573 /// OverEmptyLines: 2 574 /// \endcode 575 /// \version 3.7 576 TrailingCommentsAlignmentStyle AlignTrailingComments; 577 578 /// \brief If a function call or braced initializer list doesn't fit on a 579 /// line, allow putting all arguments onto the next line, even if 580 /// ``BinPackArguments`` is ``false``. 581 /// \code 582 /// true: 583 /// callFunction( 584 /// a, b, c, d); 585 /// 586 /// false: 587 /// callFunction(a, 588 /// b, 589 /// c, 590 /// d); 591 /// \endcode 592 /// \version 9 593 bool AllowAllArgumentsOnNextLine; 594 595 /// This option is **deprecated**. See ``NextLine`` of 596 /// ``PackConstructorInitializers``. 597 /// \version 9 598 // bool AllowAllConstructorInitializersOnNextLine; 599 600 /// If the function declaration doesn't fit on a line, 601 /// allow putting all parameters of a function declaration onto 602 /// the next line even if ``BinPackParameters`` is ``false``. 603 /// \code 604 /// true: 605 /// void myFunction( 606 /// int a, int b, int c, int d, int e); 607 /// 608 /// false: 609 /// void myFunction(int a, 610 /// int b, 611 /// int c, 612 /// int d, 613 /// int e); 614 /// \endcode 615 /// \version 3.3 616 bool AllowAllParametersOfDeclarationOnNextLine; 617 618 /// Different ways to break before a noexcept specifier. 619 enum BreakBeforeNoexceptSpecifierStyle : int8_t { 620 /// No line break allowed. 621 /// \code 622 /// void foo(int arg1, 623 /// double arg2) noexcept; 624 /// 625 /// void bar(int arg1, double arg2) noexcept( 626 /// noexcept(baz(arg1)) && 627 /// noexcept(baz(arg2))); 628 /// \endcode 629 BBNSS_Never, 630 /// For a simple ``noexcept`` there is no line break allowed, but when we 631 /// have a condition it is. 632 /// \code 633 /// void foo(int arg1, 634 /// double arg2) noexcept; 635 /// 636 /// void bar(int arg1, double arg2) 637 /// noexcept(noexcept(baz(arg1)) && 638 /// noexcept(baz(arg2))); 639 /// \endcode 640 BBNSS_OnlyWithParen, 641 /// Line breaks are allowed. But note that because of the associated 642 /// penalties ``clang-format`` often prefers not to break before the 643 /// ``noexcept``. 644 /// \code 645 /// void foo(int arg1, 646 /// double arg2) noexcept; 647 /// 648 /// void bar(int arg1, double arg2) 649 /// noexcept(noexcept(baz(arg1)) && 650 /// noexcept(baz(arg2))); 651 /// \endcode 652 BBNSS_Always, 653 }; 654 655 /// Controls if there could be a line break before a ``noexcept`` specifier. 656 /// \version 18 657 BreakBeforeNoexceptSpecifierStyle AllowBreakBeforeNoexceptSpecifier; 658 659 /// Different styles for merging short blocks containing at most one 660 /// statement. 661 enum ShortBlockStyle : int8_t { 662 /// Never merge blocks into a single line. 663 /// \code 664 /// while (true) { 665 /// } 666 /// while (true) { 667 /// continue; 668 /// } 669 /// \endcode 670 SBS_Never, 671 /// Only merge empty blocks. 672 /// \code 673 /// while (true) {} 674 /// while (true) { 675 /// continue; 676 /// } 677 /// \endcode 678 SBS_Empty, 679 /// Always merge short blocks into a single line. 680 /// \code 681 /// while (true) {} 682 /// while (true) { continue; } 683 /// \endcode 684 SBS_Always, 685 }; 686 687 /// Dependent on the value, ``while (true) { continue; }`` can be put on a 688 /// single line. 689 /// \version 3.5 690 ShortBlockStyle AllowShortBlocksOnASingleLine; 691 692 /// If ``true``, short case labels will be contracted to a single line. 693 /// \code 694 /// true: false: 695 /// switch (a) { vs. switch (a) { 696 /// case 1: x = 1; break; case 1: 697 /// case 2: return; x = 1; 698 /// } break; 699 /// case 2: 700 /// return; 701 /// } 702 /// \endcode 703 /// \version 3.6 704 bool AllowShortCaseLabelsOnASingleLine; 705 706 /// Allow short compound requirement on a single line. 707 /// \code 708 /// true: 709 /// template <typename T> 710 /// concept c = requires(T x) { 711 /// { x + 1 } -> std::same_as<int>; 712 /// }; 713 /// 714 /// false: 715 /// template <typename T> 716 /// concept c = requires(T x) { 717 /// { 718 /// x + 1 719 /// } -> std::same_as<int>; 720 /// }; 721 /// \endcode 722 /// \version 18 723 bool AllowShortCompoundRequirementOnASingleLine; 724 725 /// Allow short enums on a single line. 726 /// \code 727 /// true: 728 /// enum { A, B } myEnum; 729 /// 730 /// false: 731 /// enum { 732 /// A, 733 /// B 734 /// } myEnum; 735 /// \endcode 736 /// \version 11 737 bool AllowShortEnumsOnASingleLine; 738 739 /// Different styles for merging short functions containing at most one 740 /// statement. 741 enum ShortFunctionStyle : int8_t { 742 /// Never merge functions into a single line. 743 SFS_None, 744 /// Only merge functions defined inside a class. Same as "inline", 745 /// except it does not implies "empty": i.e. top level empty functions 746 /// are not merged either. 747 /// \code 748 /// class Foo { 749 /// void f() { foo(); } 750 /// }; 751 /// void f() { 752 /// foo(); 753 /// } 754 /// void f() { 755 /// } 756 /// \endcode 757 SFS_InlineOnly, 758 /// Only merge empty functions. 759 /// \code 760 /// void f() {} 761 /// void f2() { 762 /// bar2(); 763 /// } 764 /// \endcode 765 SFS_Empty, 766 /// Only merge functions defined inside a class. Implies "empty". 767 /// \code 768 /// class Foo { 769 /// void f() { foo(); } 770 /// }; 771 /// void f() { 772 /// foo(); 773 /// } 774 /// void f() {} 775 /// \endcode 776 SFS_Inline, 777 /// Merge all functions fitting on a single line. 778 /// \code 779 /// class Foo { 780 /// void f() { foo(); } 781 /// }; 782 /// void f() { bar(); } 783 /// \endcode 784 SFS_All, 785 }; 786 787 /// Dependent on the value, ``int f() { return 0; }`` can be put on a 788 /// single line. 789 /// \version 3.5 790 ShortFunctionStyle AllowShortFunctionsOnASingleLine; 791 792 /// Different styles for handling short if statements. 793 enum ShortIfStyle : int8_t { 794 /// Never put short ifs on the same line. 795 /// \code 796 /// if (a) 797 /// return; 798 /// 799 /// if (b) 800 /// return; 801 /// else 802 /// return; 803 /// 804 /// if (c) 805 /// return; 806 /// else { 807 /// return; 808 /// } 809 /// \endcode 810 SIS_Never, 811 /// Put short ifs on the same line only if there is no else statement. 812 /// \code 813 /// if (a) return; 814 /// 815 /// if (b) 816 /// return; 817 /// else 818 /// return; 819 /// 820 /// if (c) 821 /// return; 822 /// else { 823 /// return; 824 /// } 825 /// \endcode 826 SIS_WithoutElse, 827 /// Put short ifs, but not else ifs nor else statements, on the same line. 828 /// \code 829 /// if (a) return; 830 /// 831 /// if (b) return; 832 /// else if (b) 833 /// return; 834 /// else 835 /// return; 836 /// 837 /// if (c) return; 838 /// else { 839 /// return; 840 /// } 841 /// \endcode 842 SIS_OnlyFirstIf, 843 /// Always put short ifs, else ifs and else statements on the same 844 /// line. 845 /// \code 846 /// if (a) return; 847 /// 848 /// if (b) return; 849 /// else return; 850 /// 851 /// if (c) return; 852 /// else { 853 /// return; 854 /// } 855 /// \endcode 856 SIS_AllIfsAndElse, 857 }; 858 859 /// Dependent on the value, ``if (a) return;`` can be put on a single line. 860 /// \version 3.3 861 ShortIfStyle AllowShortIfStatementsOnASingleLine; 862 863 /// Different styles for merging short lambdas containing at most one 864 /// statement. 865 enum ShortLambdaStyle : int8_t { 866 /// Never merge lambdas into a single line. 867 SLS_None, 868 /// Only merge empty lambdas. 869 /// \code 870 /// auto lambda = [](int a) {}; 871 /// auto lambda2 = [](int a) { 872 /// return a; 873 /// }; 874 /// \endcode 875 SLS_Empty, 876 /// Merge lambda into a single line if the lambda is argument of a function. 877 /// \code 878 /// auto lambda = [](int x, int y) { 879 /// return x < y; 880 /// }; 881 /// sort(a.begin(), a.end(), [](int x, int y) { return x < y; }); 882 /// \endcode 883 SLS_Inline, 884 /// Merge all lambdas fitting on a single line. 885 /// \code 886 /// auto lambda = [](int a) {}; 887 /// auto lambda2 = [](int a) { return a; }; 888 /// \endcode 889 SLS_All, 890 }; 891 892 /// Dependent on the value, ``auto lambda []() { return 0; }`` can be put on a 893 /// single line. 894 /// \version 9 895 ShortLambdaStyle AllowShortLambdasOnASingleLine; 896 897 /// If ``true``, ``while (true) continue;`` can be put on a single 898 /// line. 899 /// \version 3.7 900 bool AllowShortLoopsOnASingleLine; 901 902 /// Different ways to break after the function definition return type. 903 /// This option is **deprecated** and is retained for backwards compatibility. 904 enum DefinitionReturnTypeBreakingStyle : int8_t { 905 /// Break after return type automatically. 906 /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account. 907 DRTBS_None, 908 /// Always break after the return type. 909 DRTBS_All, 910 /// Always break after the return types of top-level functions. 911 DRTBS_TopLevel, 912 }; 913 914 /// Different ways to break after the function definition or 915 /// declaration return type. 916 enum ReturnTypeBreakingStyle : int8_t { 917 /// Break after return type automatically. 918 /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account. 919 /// \code 920 /// class A { 921 /// int f() { return 0; }; 922 /// }; 923 /// int f(); 924 /// int f() { return 1; } 925 /// \endcode 926 RTBS_None, 927 /// Always break after the return type. 928 /// \code 929 /// class A { 930 /// int 931 /// f() { 932 /// return 0; 933 /// }; 934 /// }; 935 /// int 936 /// f(); 937 /// int 938 /// f() { 939 /// return 1; 940 /// } 941 /// \endcode 942 RTBS_All, 943 /// Always break after the return types of top-level functions. 944 /// \code 945 /// class A { 946 /// int f() { return 0; }; 947 /// }; 948 /// int 949 /// f(); 950 /// int 951 /// f() { 952 /// return 1; 953 /// } 954 /// \endcode 955 RTBS_TopLevel, 956 /// Always break after the return type of function definitions. 957 /// \code 958 /// class A { 959 /// int 960 /// f() { 961 /// return 0; 962 /// }; 963 /// }; 964 /// int f(); 965 /// int 966 /// f() { 967 /// return 1; 968 /// } 969 /// \endcode 970 RTBS_AllDefinitions, 971 /// Always break after the return type of top-level definitions. 972 /// \code 973 /// class A { 974 /// int f() { return 0; }; 975 /// }; 976 /// int f(); 977 /// int 978 /// f() { 979 /// return 1; 980 /// } 981 /// \endcode 982 RTBS_TopLevelDefinitions, 983 }; 984 985 /// The function definition return type breaking style to use. This 986 /// option is **deprecated** and is retained for backwards compatibility. 987 /// \version 3.7 988 DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType; 989 990 /// The function declaration return type breaking style to use. 991 /// \version 3.8 992 ReturnTypeBreakingStyle AlwaysBreakAfterReturnType; 993 994 /// If ``true``, always break before multiline string literals. 995 /// 996 /// This flag is mean to make cases where there are multiple multiline strings 997 /// in a file look more consistent. Thus, it will only take effect if wrapping 998 /// the string at that point leads to it being indented 999 /// ``ContinuationIndentWidth`` spaces from the start of the line. 1000 /// \code 1001 /// true: false: 1002 /// aaaa = vs. aaaa = "bbbb" 1003 /// "bbbb" "cccc"; 1004 /// "cccc"; 1005 /// \endcode 1006 /// \version 3.4 1007 bool AlwaysBreakBeforeMultilineStrings; 1008 1009 /// Different ways to break after the template declaration. 1010 enum BreakTemplateDeclarationsStyle : int8_t { 1011 /// Do not force break before declaration. 1012 /// ``PenaltyBreakTemplateDeclaration`` is taken into account. 1013 /// \code 1014 /// template <typename T> T foo() { 1015 /// } 1016 /// template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa, 1017 /// int bbbbbbbbbbbbbbbbbbbbb) { 1018 /// } 1019 /// \endcode 1020 BTDS_No, 1021 /// Force break after template declaration only when the following 1022 /// declaration spans multiple lines. 1023 /// \code 1024 /// template <typename T> T foo() { 1025 /// } 1026 /// template <typename T> 1027 /// T foo(int aaaaaaaaaaaaaaaaaaaaa, 1028 /// int bbbbbbbbbbbbbbbbbbbbb) { 1029 /// } 1030 /// \endcode 1031 BTDS_MultiLine, 1032 /// Always break after template declaration. 1033 /// \code 1034 /// template <typename T> 1035 /// T foo() { 1036 /// } 1037 /// template <typename T> 1038 /// T foo(int aaaaaaaaaaaaaaaaaaaaa, 1039 /// int bbbbbbbbbbbbbbbbbbbbb) { 1040 /// } 1041 /// \endcode 1042 BTDS_Yes 1043 }; 1044 1045 /// The template declaration breaking style to use. 1046 /// \version 3.4 1047 BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations; 1048 1049 /// A vector of strings that should be interpreted as attributes/qualifiers 1050 /// instead of identifiers. This can be useful for language extensions or 1051 /// static analyzer annotations. 1052 /// 1053 /// For example: 1054 /// \code 1055 /// x = (char *__capability)&y; 1056 /// int function(void) __unused; 1057 /// void only_writes_to_buffer(char *__output buffer); 1058 /// \endcode 1059 /// 1060 /// In the .clang-format configuration file, this can be configured like: 1061 /// \code{.yaml} 1062 /// AttributeMacros: ['__capability', '__output', '__unused'] 1063 /// \endcode 1064 /// 1065 /// \version 12 1066 std::vector<std::string> AttributeMacros; 1067 1068 /// If ``false``, a function call's arguments will either be all on the 1069 /// same line or will have one line each. 1070 /// \code 1071 /// true: 1072 /// void f() { 1073 /// f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa, 1074 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); 1075 /// } 1076 /// 1077 /// false: 1078 /// void f() { 1079 /// f(aaaaaaaaaaaaaaaaaaaa, 1080 /// aaaaaaaaaaaaaaaaaaaa, 1081 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); 1082 /// } 1083 /// \endcode 1084 /// \version 3.7 1085 bool BinPackArguments; 1086 1087 /// If ``false``, a function declaration's or function definition's 1088 /// parameters will either all be on the same line or will have one line each. 1089 /// \code 1090 /// true: 1091 /// void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa, 1092 /// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {} 1093 /// 1094 /// false: 1095 /// void f(int aaaaaaaaaaaaaaaaaaaa, 1096 /// int aaaaaaaaaaaaaaaaaaaa, 1097 /// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {} 1098 /// \endcode 1099 /// \version 3.7 1100 bool BinPackParameters; 1101 1102 /// Styles for adding spacing around ``:`` in bitfield definitions. 1103 enum BitFieldColonSpacingStyle : int8_t { 1104 /// Add one space on each side of the ``:`` 1105 /// \code 1106 /// unsigned bf : 2; 1107 /// \endcode 1108 BFCS_Both, 1109 /// Add no space around the ``:`` (except when needed for 1110 /// ``AlignConsecutiveBitFields``). 1111 /// \code 1112 /// unsigned bf:2; 1113 /// \endcode 1114 BFCS_None, 1115 /// Add space before the ``:`` only 1116 /// \code 1117 /// unsigned bf :2; 1118 /// \endcode 1119 BFCS_Before, 1120 /// Add space after the ``:`` only (space may be added before if 1121 /// needed for ``AlignConsecutiveBitFields``). 1122 /// \code 1123 /// unsigned bf: 2; 1124 /// \endcode 1125 BFCS_After 1126 }; 1127 /// The BitFieldColonSpacingStyle to use for bitfields. 1128 /// \version 12 1129 BitFieldColonSpacingStyle BitFieldColonSpacing; 1130 1131 /// The number of columns to use to indent the contents of braced init lists. 1132 /// If unset, ``ContinuationIndentWidth`` is used. 1133 /// \code 1134 /// AlignAfterOpenBracket: AlwaysBreak 1135 /// BracedInitializerIndentWidth: 2 1136 /// 1137 /// void f() { 1138 /// SomeClass c{ 1139 /// "foo", 1140 /// "bar", 1141 /// "baz", 1142 /// }; 1143 /// auto s = SomeStruct{ 1144 /// .foo = "foo", 1145 /// .bar = "bar", 1146 /// .baz = "baz", 1147 /// }; 1148 /// SomeArrayT a[3] = { 1149 /// { 1150 /// foo, 1151 /// bar, 1152 /// }, 1153 /// { 1154 /// foo, 1155 /// bar, 1156 /// }, 1157 /// SomeArrayT{}, 1158 /// }; 1159 /// } 1160 /// \endcode 1161 /// \version 17 1162 std::optional<unsigned> BracedInitializerIndentWidth; 1163 1164 /// Different ways to wrap braces after control statements. 1165 enum BraceWrappingAfterControlStatementStyle : int8_t { 1166 /// Never wrap braces after a control statement. 1167 /// \code 1168 /// if (foo()) { 1169 /// } else { 1170 /// } 1171 /// for (int i = 0; i < 10; ++i) { 1172 /// } 1173 /// \endcode 1174 BWACS_Never, 1175 /// Only wrap braces after a multi-line control statement. 1176 /// \code 1177 /// if (foo && bar && 1178 /// baz) 1179 /// { 1180 /// quux(); 1181 /// } 1182 /// while (foo || bar) { 1183 /// } 1184 /// \endcode 1185 BWACS_MultiLine, 1186 /// Always wrap braces after a control statement. 1187 /// \code 1188 /// if (foo()) 1189 /// { 1190 /// } else 1191 /// {} 1192 /// for (int i = 0; i < 10; ++i) 1193 /// {} 1194 /// \endcode 1195 BWACS_Always 1196 }; 1197 1198 /// Precise control over the wrapping of braces. 1199 /// \code 1200 /// # Should be declared this way: 1201 /// BreakBeforeBraces: Custom 1202 /// BraceWrapping: 1203 /// AfterClass: true 1204 /// \endcode 1205 struct BraceWrappingFlags { 1206 /// Wrap case labels. 1207 /// \code 1208 /// false: true: 1209 /// switch (foo) { vs. switch (foo) { 1210 /// case 1: { case 1: 1211 /// bar(); { 1212 /// break; bar(); 1213 /// } break; 1214 /// default: { } 1215 /// plop(); default: 1216 /// } { 1217 /// } plop(); 1218 /// } 1219 /// } 1220 /// \endcode 1221 bool AfterCaseLabel; 1222 /// Wrap class definitions. 1223 /// \code 1224 /// true: 1225 /// class foo 1226 /// {}; 1227 /// 1228 /// false: 1229 /// class foo {}; 1230 /// \endcode 1231 bool AfterClass; 1232 1233 /// Wrap control statements (``if``/``for``/``while``/``switch``/..). 1234 BraceWrappingAfterControlStatementStyle AfterControlStatement; 1235 /// Wrap enum definitions. 1236 /// \code 1237 /// true: 1238 /// enum X : int 1239 /// { 1240 /// B 1241 /// }; 1242 /// 1243 /// false: 1244 /// enum X : int { B }; 1245 /// \endcode 1246 bool AfterEnum; 1247 /// Wrap function definitions. 1248 /// \code 1249 /// true: 1250 /// void foo() 1251 /// { 1252 /// bar(); 1253 /// bar2(); 1254 /// } 1255 /// 1256 /// false: 1257 /// void foo() { 1258 /// bar(); 1259 /// bar2(); 1260 /// } 1261 /// \endcode 1262 bool AfterFunction; 1263 /// Wrap namespace definitions. 1264 /// \code 1265 /// true: 1266 /// namespace 1267 /// { 1268 /// int foo(); 1269 /// int bar(); 1270 /// } 1271 /// 1272 /// false: 1273 /// namespace { 1274 /// int foo(); 1275 /// int bar(); 1276 /// } 1277 /// \endcode 1278 bool AfterNamespace; 1279 /// Wrap ObjC definitions (interfaces, implementations...). 1280 /// \note 1281 /// @autoreleasepool and @synchronized blocks are wrapped 1282 /// according to ``AfterControlStatement`` flag. 1283 /// \endnote 1284 bool AfterObjCDeclaration; 1285 /// Wrap struct definitions. 1286 /// \code 1287 /// true: 1288 /// struct foo 1289 /// { 1290 /// int x; 1291 /// }; 1292 /// 1293 /// false: 1294 /// struct foo { 1295 /// int x; 1296 /// }; 1297 /// \endcode 1298 bool AfterStruct; 1299 /// Wrap union definitions. 1300 /// \code 1301 /// true: 1302 /// union foo 1303 /// { 1304 /// int x; 1305 /// } 1306 /// 1307 /// false: 1308 /// union foo { 1309 /// int x; 1310 /// } 1311 /// \endcode 1312 bool AfterUnion; 1313 /// Wrap extern blocks. 1314 /// \code 1315 /// true: 1316 /// extern "C" 1317 /// { 1318 /// int foo(); 1319 /// } 1320 /// 1321 /// false: 1322 /// extern "C" { 1323 /// int foo(); 1324 /// } 1325 /// \endcode 1326 bool AfterExternBlock; // Partially superseded by IndentExternBlock 1327 /// Wrap before ``catch``. 1328 /// \code 1329 /// true: 1330 /// try { 1331 /// foo(); 1332 /// } 1333 /// catch () { 1334 /// } 1335 /// 1336 /// false: 1337 /// try { 1338 /// foo(); 1339 /// } catch () { 1340 /// } 1341 /// \endcode 1342 bool BeforeCatch; 1343 /// Wrap before ``else``. 1344 /// \code 1345 /// true: 1346 /// if (foo()) { 1347 /// } 1348 /// else { 1349 /// } 1350 /// 1351 /// false: 1352 /// if (foo()) { 1353 /// } else { 1354 /// } 1355 /// \endcode 1356 bool BeforeElse; 1357 /// Wrap lambda block. 1358 /// \code 1359 /// true: 1360 /// connect( 1361 /// []() 1362 /// { 1363 /// foo(); 1364 /// bar(); 1365 /// }); 1366 /// 1367 /// false: 1368 /// connect([]() { 1369 /// foo(); 1370 /// bar(); 1371 /// }); 1372 /// \endcode 1373 bool BeforeLambdaBody; 1374 /// Wrap before ``while``. 1375 /// \code 1376 /// true: 1377 /// do { 1378 /// foo(); 1379 /// } 1380 /// while (1); 1381 /// 1382 /// false: 1383 /// do { 1384 /// foo(); 1385 /// } while (1); 1386 /// \endcode 1387 bool BeforeWhile; 1388 /// Indent the wrapped braces themselves. 1389 bool IndentBraces; 1390 /// If ``false``, empty function body can be put on a single line. 1391 /// This option is used only if the opening brace of the function has 1392 /// already been wrapped, i.e. the ``AfterFunction`` brace wrapping mode is 1393 /// set, and the function could/should not be put on a single line (as per 1394 /// ``AllowShortFunctionsOnASingleLine`` and constructor formatting 1395 /// options). 1396 /// \code 1397 /// false: true: 1398 /// int f() vs. int f() 1399 /// {} { 1400 /// } 1401 /// \endcode 1402 /// 1403 bool SplitEmptyFunction; 1404 /// If ``false``, empty record (e.g. class, struct or union) body 1405 /// can be put on a single line. This option is used only if the opening 1406 /// brace of the record has already been wrapped, i.e. the ``AfterClass`` 1407 /// (for classes) brace wrapping mode is set. 1408 /// \code 1409 /// false: true: 1410 /// class Foo vs. class Foo 1411 /// {} { 1412 /// } 1413 /// \endcode 1414 /// 1415 bool SplitEmptyRecord; 1416 /// If ``false``, empty namespace body can be put on a single line. 1417 /// This option is used only if the opening brace of the namespace has 1418 /// already been wrapped, i.e. the ``AfterNamespace`` brace wrapping mode is 1419 /// set. 1420 /// \code 1421 /// false: true: 1422 /// namespace Foo vs. namespace Foo 1423 /// {} { 1424 /// } 1425 /// \endcode 1426 /// 1427 bool SplitEmptyNamespace; 1428 }; 1429 1430 /// Control of individual brace wrapping cases. 1431 /// 1432 /// If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how 1433 /// each individual brace case should be handled. Otherwise, this is ignored. 1434 /// \code{.yaml} 1435 /// # Example of usage: 1436 /// BreakBeforeBraces: Custom 1437 /// BraceWrapping: 1438 /// AfterEnum: true 1439 /// AfterStruct: false 1440 /// SplitEmptyFunction: false 1441 /// \endcode 1442 /// \version 3.8 1443 BraceWrappingFlags BraceWrapping; 1444 1445 /// Break between adjacent string literals. 1446 /// \code 1447 /// true: 1448 /// return "Code" 1449 /// "\0\52\26\55\55\0" 1450 /// "x013" 1451 /// "\02\xBA"; 1452 /// false: 1453 /// return "Code" "\0\52\26\55\55\0" "x013" "\02\xBA"; 1454 /// \endcode 1455 /// \version 18 1456 bool BreakAdjacentStringLiterals; 1457 1458 /// Different ways to break after attributes. 1459 enum AttributeBreakingStyle : int8_t { 1460 /// Always break after attributes. 1461 /// \code 1462 /// [[maybe_unused]] 1463 /// const int i; 1464 /// [[gnu::const]] [[maybe_unused]] 1465 /// int j; 1466 /// 1467 /// [[nodiscard]] 1468 /// inline int f(); 1469 /// [[gnu::const]] [[nodiscard]] 1470 /// int g(); 1471 /// 1472 /// [[likely]] 1473 /// if (a) 1474 /// f(); 1475 /// else 1476 /// g(); 1477 /// 1478 /// switch (b) { 1479 /// [[unlikely]] 1480 /// case 1: 1481 /// ++b; 1482 /// break; 1483 /// [[likely]] 1484 /// default: 1485 /// return; 1486 /// } 1487 /// \endcode 1488 ABS_Always, 1489 /// Leave the line breaking after attributes as is. 1490 /// \code 1491 /// [[maybe_unused]] const int i; 1492 /// [[gnu::const]] [[maybe_unused]] 1493 /// int j; 1494 /// 1495 /// [[nodiscard]] inline int f(); 1496 /// [[gnu::const]] [[nodiscard]] 1497 /// int g(); 1498 /// 1499 /// [[likely]] if (a) 1500 /// f(); 1501 /// else 1502 /// g(); 1503 /// 1504 /// switch (b) { 1505 /// [[unlikely]] case 1: 1506 /// ++b; 1507 /// break; 1508 /// [[likely]] 1509 /// default: 1510 /// return; 1511 /// } 1512 /// \endcode 1513 ABS_Leave, 1514 /// Never break after attributes. 1515 /// \code 1516 /// [[maybe_unused]] const int i; 1517 /// [[gnu::const]] [[maybe_unused]] int j; 1518 /// 1519 /// [[nodiscard]] inline int f(); 1520 /// [[gnu::const]] [[nodiscard]] int g(); 1521 /// 1522 /// [[likely]] if (a) 1523 /// f(); 1524 /// else 1525 /// g(); 1526 /// 1527 /// switch (b) { 1528 /// [[unlikely]] case 1: 1529 /// ++b; 1530 /// break; 1531 /// [[likely]] default: 1532 /// return; 1533 /// } 1534 /// \endcode 1535 ABS_Never, 1536 }; 1537 1538 /// Break after a group of C++11 attributes before variable or function 1539 /// (including constructor/destructor) declaration/definition names or before 1540 /// control statements, i.e. ``if``, ``switch`` (including ``case`` and 1541 /// ``default`` labels), ``for``, and ``while`` statements. 1542 /// \version 16 1543 AttributeBreakingStyle BreakAfterAttributes; 1544 1545 /// If ``true``, clang-format will always break after a Json array ``[`` 1546 /// otherwise it will scan until the closing ``]`` to determine if it should 1547 /// add newlines between elements (prettier compatible). 1548 /// 1549 /// \note 1550 /// This is currently only for formatting JSON. 1551 /// \endnote 1552 /// \code 1553 /// true: false: 1554 /// [ vs. [1, 2, 3, 4] 1555 /// 1, 1556 /// 2, 1557 /// 3, 1558 /// 4 1559 /// ] 1560 /// \endcode 1561 /// \version 16 1562 bool BreakArrays; 1563 1564 /// The style of wrapping parameters on the same line (bin-packed) or 1565 /// on one line each. 1566 enum BinPackStyle : int8_t { 1567 /// Automatically determine parameter bin-packing behavior. 1568 BPS_Auto, 1569 /// Always bin-pack parameters. 1570 BPS_Always, 1571 /// Never bin-pack parameters. 1572 BPS_Never, 1573 }; 1574 1575 /// The style of breaking before or after binary operators. 1576 enum BinaryOperatorStyle : int8_t { 1577 /// Break after operators. 1578 /// \code 1579 /// LooooooooooongType loooooooooooooooooooooongVariable = 1580 /// someLooooooooooooooooongFunction(); 1581 /// 1582 /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + 1583 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == 1584 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && 1585 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > 1586 /// ccccccccccccccccccccccccccccccccccccccccc; 1587 /// \endcode 1588 BOS_None, 1589 /// Break before operators that aren't assignments. 1590 /// \code 1591 /// LooooooooooongType loooooooooooooooooooooongVariable = 1592 /// someLooooooooooooooooongFunction(); 1593 /// 1594 /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1595 /// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1596 /// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1597 /// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1598 /// > ccccccccccccccccccccccccccccccccccccccccc; 1599 /// \endcode 1600 BOS_NonAssignment, 1601 /// Break before operators. 1602 /// \code 1603 /// LooooooooooongType loooooooooooooooooooooongVariable 1604 /// = someLooooooooooooooooongFunction(); 1605 /// 1606 /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1607 /// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1608 /// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1609 /// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1610 /// > ccccccccccccccccccccccccccccccccccccccccc; 1611 /// \endcode 1612 BOS_All, 1613 }; 1614 1615 /// The way to wrap binary operators. 1616 /// \version 3.6 1617 BinaryOperatorStyle BreakBeforeBinaryOperators; 1618 1619 /// Different ways to attach braces to their surrounding context. 1620 enum BraceBreakingStyle : int8_t { 1621 /// Always attach braces to surrounding context. 1622 /// \code 1623 /// namespace N { 1624 /// enum E { 1625 /// E1, 1626 /// E2, 1627 /// }; 1628 /// 1629 /// class C { 1630 /// public: 1631 /// C(); 1632 /// }; 1633 /// 1634 /// bool baz(int i) { 1635 /// try { 1636 /// do { 1637 /// switch (i) { 1638 /// case 1: { 1639 /// foobar(); 1640 /// break; 1641 /// } 1642 /// default: { 1643 /// break; 1644 /// } 1645 /// } 1646 /// } while (--i); 1647 /// return true; 1648 /// } catch (...) { 1649 /// handleError(); 1650 /// return false; 1651 /// } 1652 /// } 1653 /// 1654 /// void foo(bool b) { 1655 /// if (b) { 1656 /// baz(2); 1657 /// } else { 1658 /// baz(5); 1659 /// } 1660 /// } 1661 /// 1662 /// void bar() { foo(true); } 1663 /// } // namespace N 1664 /// \endcode 1665 BS_Attach, 1666 /// Like ``Attach``, but break before braces on function, namespace and 1667 /// class definitions. 1668 /// \code 1669 /// namespace N 1670 /// { 1671 /// enum E { 1672 /// E1, 1673 /// E2, 1674 /// }; 1675 /// 1676 /// class C 1677 /// { 1678 /// public: 1679 /// C(); 1680 /// }; 1681 /// 1682 /// bool baz(int i) 1683 /// { 1684 /// try { 1685 /// do { 1686 /// switch (i) { 1687 /// case 1: { 1688 /// foobar(); 1689 /// break; 1690 /// } 1691 /// default: { 1692 /// break; 1693 /// } 1694 /// } 1695 /// } while (--i); 1696 /// return true; 1697 /// } catch (...) { 1698 /// handleError(); 1699 /// return false; 1700 /// } 1701 /// } 1702 /// 1703 /// void foo(bool b) 1704 /// { 1705 /// if (b) { 1706 /// baz(2); 1707 /// } else { 1708 /// baz(5); 1709 /// } 1710 /// } 1711 /// 1712 /// void bar() { foo(true); } 1713 /// } // namespace N 1714 /// \endcode 1715 BS_Linux, 1716 /// Like ``Attach``, but break before braces on enum, function, and record 1717 /// definitions. 1718 /// \code 1719 /// namespace N { 1720 /// enum E 1721 /// { 1722 /// E1, 1723 /// E2, 1724 /// }; 1725 /// 1726 /// class C 1727 /// { 1728 /// public: 1729 /// C(); 1730 /// }; 1731 /// 1732 /// bool baz(int i) 1733 /// { 1734 /// try { 1735 /// do { 1736 /// switch (i) { 1737 /// case 1: { 1738 /// foobar(); 1739 /// break; 1740 /// } 1741 /// default: { 1742 /// break; 1743 /// } 1744 /// } 1745 /// } while (--i); 1746 /// return true; 1747 /// } catch (...) { 1748 /// handleError(); 1749 /// return false; 1750 /// } 1751 /// } 1752 /// 1753 /// void foo(bool b) 1754 /// { 1755 /// if (b) { 1756 /// baz(2); 1757 /// } else { 1758 /// baz(5); 1759 /// } 1760 /// } 1761 /// 1762 /// void bar() { foo(true); } 1763 /// } // namespace N 1764 /// \endcode 1765 BS_Mozilla, 1766 /// Like ``Attach``, but break before function definitions, ``catch``, and 1767 /// ``else``. 1768 /// \code 1769 /// namespace N { 1770 /// enum E { 1771 /// E1, 1772 /// E2, 1773 /// }; 1774 /// 1775 /// class C { 1776 /// public: 1777 /// C(); 1778 /// }; 1779 /// 1780 /// bool baz(int i) 1781 /// { 1782 /// try { 1783 /// do { 1784 /// switch (i) { 1785 /// case 1: { 1786 /// foobar(); 1787 /// break; 1788 /// } 1789 /// default: { 1790 /// break; 1791 /// } 1792 /// } 1793 /// } while (--i); 1794 /// return true; 1795 /// } 1796 /// catch (...) { 1797 /// handleError(); 1798 /// return false; 1799 /// } 1800 /// } 1801 /// 1802 /// void foo(bool b) 1803 /// { 1804 /// if (b) { 1805 /// baz(2); 1806 /// } 1807 /// else { 1808 /// baz(5); 1809 /// } 1810 /// } 1811 /// 1812 /// void bar() { foo(true); } 1813 /// } // namespace N 1814 /// \endcode 1815 BS_Stroustrup, 1816 /// Always break before braces. 1817 /// \code 1818 /// namespace N 1819 /// { 1820 /// enum E 1821 /// { 1822 /// E1, 1823 /// E2, 1824 /// }; 1825 /// 1826 /// class C 1827 /// { 1828 /// public: 1829 /// C(); 1830 /// }; 1831 /// 1832 /// bool baz(int i) 1833 /// { 1834 /// try 1835 /// { 1836 /// do 1837 /// { 1838 /// switch (i) 1839 /// { 1840 /// case 1: 1841 /// { 1842 /// foobar(); 1843 /// break; 1844 /// } 1845 /// default: 1846 /// { 1847 /// break; 1848 /// } 1849 /// } 1850 /// } while (--i); 1851 /// return true; 1852 /// } 1853 /// catch (...) 1854 /// { 1855 /// handleError(); 1856 /// return false; 1857 /// } 1858 /// } 1859 /// 1860 /// void foo(bool b) 1861 /// { 1862 /// if (b) 1863 /// { 1864 /// baz(2); 1865 /// } 1866 /// else 1867 /// { 1868 /// baz(5); 1869 /// } 1870 /// } 1871 /// 1872 /// void bar() { foo(true); } 1873 /// } // namespace N 1874 /// \endcode 1875 BS_Allman, 1876 /// Like ``Allman`` but always indent braces and line up code with braces. 1877 /// \code 1878 /// namespace N 1879 /// { 1880 /// enum E 1881 /// { 1882 /// E1, 1883 /// E2, 1884 /// }; 1885 /// 1886 /// class C 1887 /// { 1888 /// public: 1889 /// C(); 1890 /// }; 1891 /// 1892 /// bool baz(int i) 1893 /// { 1894 /// try 1895 /// { 1896 /// do 1897 /// { 1898 /// switch (i) 1899 /// { 1900 /// case 1: 1901 /// { 1902 /// foobar(); 1903 /// break; 1904 /// } 1905 /// default: 1906 /// { 1907 /// break; 1908 /// } 1909 /// } 1910 /// } while (--i); 1911 /// return true; 1912 /// } 1913 /// catch (...) 1914 /// { 1915 /// handleError(); 1916 /// return false; 1917 /// } 1918 /// } 1919 /// 1920 /// void foo(bool b) 1921 /// { 1922 /// if (b) 1923 /// { 1924 /// baz(2); 1925 /// } 1926 /// else 1927 /// { 1928 /// baz(5); 1929 /// } 1930 /// } 1931 /// 1932 /// void bar() { foo(true); } 1933 /// } // namespace N 1934 /// \endcode 1935 BS_Whitesmiths, 1936 /// Always break before braces and add an extra level of indentation to 1937 /// braces of control statements, not to those of class, function 1938 /// or other definitions. 1939 /// \code 1940 /// namespace N 1941 /// { 1942 /// enum E 1943 /// { 1944 /// E1, 1945 /// E2, 1946 /// }; 1947 /// 1948 /// class C 1949 /// { 1950 /// public: 1951 /// C(); 1952 /// }; 1953 /// 1954 /// bool baz(int i) 1955 /// { 1956 /// try 1957 /// { 1958 /// do 1959 /// { 1960 /// switch (i) 1961 /// { 1962 /// case 1: 1963 /// { 1964 /// foobar(); 1965 /// break; 1966 /// } 1967 /// default: 1968 /// { 1969 /// break; 1970 /// } 1971 /// } 1972 /// } 1973 /// while (--i); 1974 /// return true; 1975 /// } 1976 /// catch (...) 1977 /// { 1978 /// handleError(); 1979 /// return false; 1980 /// } 1981 /// } 1982 /// 1983 /// void foo(bool b) 1984 /// { 1985 /// if (b) 1986 /// { 1987 /// baz(2); 1988 /// } 1989 /// else 1990 /// { 1991 /// baz(5); 1992 /// } 1993 /// } 1994 /// 1995 /// void bar() { foo(true); } 1996 /// } // namespace N 1997 /// \endcode 1998 BS_GNU, 1999 /// Like ``Attach``, but break before functions. 2000 /// \code 2001 /// namespace N { 2002 /// enum E { 2003 /// E1, 2004 /// E2, 2005 /// }; 2006 /// 2007 /// class C { 2008 /// public: 2009 /// C(); 2010 /// }; 2011 /// 2012 /// bool baz(int i) 2013 /// { 2014 /// try { 2015 /// do { 2016 /// switch (i) { 2017 /// case 1: { 2018 /// foobar(); 2019 /// break; 2020 /// } 2021 /// default: { 2022 /// break; 2023 /// } 2024 /// } 2025 /// } while (--i); 2026 /// return true; 2027 /// } catch (...) { 2028 /// handleError(); 2029 /// return false; 2030 /// } 2031 /// } 2032 /// 2033 /// void foo(bool b) 2034 /// { 2035 /// if (b) { 2036 /// baz(2); 2037 /// } else { 2038 /// baz(5); 2039 /// } 2040 /// } 2041 /// 2042 /// void bar() { foo(true); } 2043 /// } // namespace N 2044 /// \endcode 2045 BS_WebKit, 2046 /// Configure each individual brace in ``BraceWrapping``. 2047 BS_Custom 2048 }; 2049 2050 /// The brace breaking style to use. 2051 /// \version 3.7 2052 BraceBreakingStyle BreakBeforeBraces; 2053 2054 /// Different ways to break before concept declarations. 2055 enum BreakBeforeConceptDeclarationsStyle : int8_t { 2056 /// Keep the template declaration line together with ``concept``. 2057 /// \code 2058 /// template <typename T> concept C = ...; 2059 /// \endcode 2060 BBCDS_Never, 2061 /// Breaking between template declaration and ``concept`` is allowed. The 2062 /// actual behavior depends on the content and line breaking rules and 2063 /// penalties. 2064 BBCDS_Allowed, 2065 /// Always break before ``concept``, putting it in the line after the 2066 /// template declaration. 2067 /// \code 2068 /// template <typename T> 2069 /// concept C = ...; 2070 /// \endcode 2071 BBCDS_Always, 2072 }; 2073 2074 /// The concept declaration style to use. 2075 /// \version 12 2076 BreakBeforeConceptDeclarationsStyle BreakBeforeConceptDeclarations; 2077 2078 /// Different ways to break ASM parameters. 2079 enum BreakBeforeInlineASMColonStyle : int8_t { 2080 /// No break before inline ASM colon. 2081 /// \code 2082 /// asm volatile("string", : : val); 2083 /// \endcode 2084 BBIAS_Never, 2085 /// Break before inline ASM colon if the line length is longer than column 2086 /// limit. 2087 /// \code 2088 /// asm volatile("string", : : val); 2089 /// asm("cmoveq %1, %2, %[result]" 2090 /// : [result] "=r"(result) 2091 /// : "r"(test), "r"(new), "[result]"(old)); 2092 /// \endcode 2093 BBIAS_OnlyMultiline, 2094 /// Always break before inline ASM colon. 2095 /// \code 2096 /// asm volatile("string", 2097 /// : 2098 /// : val); 2099 /// \endcode 2100 BBIAS_Always, 2101 }; 2102 2103 /// The inline ASM colon style to use. 2104 /// \version 16 2105 BreakBeforeInlineASMColonStyle BreakBeforeInlineASMColon; 2106 2107 /// If ``true``, ternary operators will be placed after line breaks. 2108 /// \code 2109 /// true: 2110 /// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription 2111 /// ? firstValue 2112 /// : SecondValueVeryVeryVeryVeryLong; 2113 /// 2114 /// false: 2115 /// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ? 2116 /// firstValue : 2117 /// SecondValueVeryVeryVeryVeryLong; 2118 /// \endcode 2119 /// \version 3.7 2120 bool BreakBeforeTernaryOperators; 2121 2122 /// Different ways to break initializers. 2123 enum BreakConstructorInitializersStyle : int8_t { 2124 /// Break constructor initializers before the colon and after the commas. 2125 /// \code 2126 /// Constructor() 2127 /// : initializer1(), 2128 /// initializer2() 2129 /// \endcode 2130 BCIS_BeforeColon, 2131 /// Break constructor initializers before the colon and commas, and align 2132 /// the commas with the colon. 2133 /// \code 2134 /// Constructor() 2135 /// : initializer1() 2136 /// , initializer2() 2137 /// \endcode 2138 BCIS_BeforeComma, 2139 /// Break constructor initializers after the colon and commas. 2140 /// \code 2141 /// Constructor() : 2142 /// initializer1(), 2143 /// initializer2() 2144 /// \endcode 2145 BCIS_AfterColon 2146 }; 2147 2148 /// The break constructor initializers style to use. 2149 /// \version 5 2150 BreakConstructorInitializersStyle BreakConstructorInitializers; 2151 2152 /// Break after each annotation on a field in Java files. 2153 /// \code{.java} 2154 /// true: false: 2155 /// @Partial vs. @Partial @Mock DataLoad loader; 2156 /// @Mock 2157 /// DataLoad loader; 2158 /// \endcode 2159 /// \version 3.8 2160 bool BreakAfterJavaFieldAnnotations; 2161 2162 /// Allow breaking string literals when formatting. 2163 /// 2164 /// In C, C++, and Objective-C: 2165 /// \code 2166 /// true: 2167 /// const char* x = "veryVeryVeryVeryVeryVe" 2168 /// "ryVeryVeryVeryVeryVery" 2169 /// "VeryLongString"; 2170 /// 2171 /// false: 2172 /// const char* x = 2173 /// "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString"; 2174 /// \endcode 2175 /// 2176 /// In C# and Java: 2177 /// \code 2178 /// true: 2179 /// string x = "veryVeryVeryVeryVeryVe" + 2180 /// "ryVeryVeryVeryVeryVery" + 2181 /// "VeryLongString"; 2182 /// 2183 /// false: 2184 /// string x = 2185 /// "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString"; 2186 /// \endcode 2187 /// 2188 /// C# interpolated strings are not broken. 2189 /// 2190 /// In Verilog: 2191 /// \code 2192 /// true: 2193 /// string x = {"veryVeryVeryVeryVeryVe", 2194 /// "ryVeryVeryVeryVeryVery", 2195 /// "VeryLongString"}; 2196 /// 2197 /// false: 2198 /// string x = 2199 /// "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString"; 2200 /// \endcode 2201 /// 2202 /// \version 3.9 2203 bool BreakStringLiterals; 2204 2205 /// The column limit. 2206 /// 2207 /// A column limit of ``0`` means that there is no column limit. In this case, 2208 /// clang-format will respect the input's line breaking decisions within 2209 /// statements unless they contradict other rules. 2210 /// \version 3.7 2211 unsigned ColumnLimit; 2212 2213 /// A regular expression that describes comments with special meaning, 2214 /// which should not be split into lines or otherwise changed. 2215 /// \code 2216 /// // CommentPragmas: '^ FOOBAR pragma:' 2217 /// // Will leave the following line unaffected 2218 /// #include <vector> // FOOBAR pragma: keep 2219 /// \endcode 2220 /// \version 3.7 2221 std::string CommentPragmas; 2222 2223 /// Different ways to break inheritance list. 2224 enum BreakInheritanceListStyle : int8_t { 2225 /// Break inheritance list before the colon and after the commas. 2226 /// \code 2227 /// class Foo 2228 /// : Base1, 2229 /// Base2 2230 /// {}; 2231 /// \endcode 2232 BILS_BeforeColon, 2233 /// Break inheritance list before the colon and commas, and align 2234 /// the commas with the colon. 2235 /// \code 2236 /// class Foo 2237 /// : Base1 2238 /// , Base2 2239 /// {}; 2240 /// \endcode 2241 BILS_BeforeComma, 2242 /// Break inheritance list after the colon and commas. 2243 /// \code 2244 /// class Foo : 2245 /// Base1, 2246 /// Base2 2247 /// {}; 2248 /// \endcode 2249 BILS_AfterColon, 2250 /// Break inheritance list only after the commas. 2251 /// \code 2252 /// class Foo : Base1, 2253 /// Base2 2254 /// {}; 2255 /// \endcode 2256 BILS_AfterComma, 2257 }; 2258 2259 /// The inheritance list style to use. 2260 /// \version 7 2261 BreakInheritanceListStyle BreakInheritanceList; 2262 2263 /// If ``true``, consecutive namespace declarations will be on the same 2264 /// line. If ``false``, each namespace is declared on a new line. 2265 /// \code 2266 /// true: 2267 /// namespace Foo { namespace Bar { 2268 /// }} 2269 /// 2270 /// false: 2271 /// namespace Foo { 2272 /// namespace Bar { 2273 /// } 2274 /// } 2275 /// \endcode 2276 /// 2277 /// If it does not fit on a single line, the overflowing namespaces get 2278 /// wrapped: 2279 /// \code 2280 /// namespace Foo { namespace Bar { 2281 /// namespace Extra { 2282 /// }}} 2283 /// \endcode 2284 /// \version 5 2285 bool CompactNamespaces; 2286 2287 /// This option is **deprecated**. See ``CurrentLine`` of 2288 /// ``PackConstructorInitializers``. 2289 /// \version 3.7 2290 // bool ConstructorInitializerAllOnOneLineOrOnePerLine; 2291 2292 /// The number of characters to use for indentation of constructor 2293 /// initializer lists as well as inheritance lists. 2294 /// \version 3.7 2295 unsigned ConstructorInitializerIndentWidth; 2296 2297 /// Indent width for line continuations. 2298 /// \code 2299 /// ContinuationIndentWidth: 2 2300 /// 2301 /// int i = // VeryVeryVeryVeryVeryLongComment 2302 /// longFunction( // Again a long comment 2303 /// arg); 2304 /// \endcode 2305 /// \version 3.7 2306 unsigned ContinuationIndentWidth; 2307 2308 /// If ``true``, format braced lists as best suited for C++11 braced 2309 /// lists. 2310 /// 2311 /// Important differences: 2312 /// - No spaces inside the braced list. 2313 /// - No line break before the closing brace. 2314 /// - Indentation with the continuation indent, not with the block indent. 2315 /// 2316 /// Fundamentally, C++11 braced lists are formatted exactly like function 2317 /// calls would be formatted in their place. If the braced list follows a name 2318 /// (e.g. a type or variable name), clang-format formats as if the ``{}`` were 2319 /// the parentheses of a function call with that name. If there is no name, 2320 /// a zero-length name is assumed. 2321 /// \code 2322 /// true: false: 2323 /// vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 }; 2324 /// vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} }; 2325 /// f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]); 2326 /// new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 }; 2327 /// \endcode 2328 /// \version 3.4 2329 bool Cpp11BracedListStyle; 2330 2331 /// This option is **deprecated**. See ``DeriveLF`` and ``DeriveCRLF`` of 2332 /// ``LineEnding``. 2333 /// \version 10 2334 // bool DeriveLineEnding; 2335 2336 /// If ``true``, analyze the formatted file for the most common 2337 /// alignment of ``&`` and ``*``. 2338 /// Pointer and reference alignment styles are going to be updated according 2339 /// to the preferences found in the file. 2340 /// ``PointerAlignment`` is then used only as fallback. 2341 /// \version 3.7 2342 bool DerivePointerAlignment; 2343 2344 /// Disables formatting completely. 2345 /// \version 3.7 2346 bool DisableFormat; 2347 2348 /// Different styles for empty line after access modifiers. 2349 /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of 2350 /// empty lines between two access modifiers. 2351 enum EmptyLineAfterAccessModifierStyle : int8_t { 2352 /// Remove all empty lines after access modifiers. 2353 /// \code 2354 /// struct foo { 2355 /// private: 2356 /// int i; 2357 /// protected: 2358 /// int j; 2359 /// /* comment */ 2360 /// public: 2361 /// foo() {} 2362 /// private: 2363 /// protected: 2364 /// }; 2365 /// \endcode 2366 ELAAMS_Never, 2367 /// Keep existing empty lines after access modifiers. 2368 /// MaxEmptyLinesToKeep is applied instead. 2369 ELAAMS_Leave, 2370 /// Always add empty line after access modifiers if there are none. 2371 /// MaxEmptyLinesToKeep is applied also. 2372 /// \code 2373 /// struct foo { 2374 /// private: 2375 /// 2376 /// int i; 2377 /// protected: 2378 /// 2379 /// int j; 2380 /// /* comment */ 2381 /// public: 2382 /// 2383 /// foo() {} 2384 /// private: 2385 /// 2386 /// protected: 2387 /// 2388 /// }; 2389 /// \endcode 2390 ELAAMS_Always, 2391 }; 2392 2393 /// Defines when to put an empty line after access modifiers. 2394 /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of 2395 /// empty lines between two access modifiers. 2396 /// \version 13 2397 EmptyLineAfterAccessModifierStyle EmptyLineAfterAccessModifier; 2398 2399 /// Different styles for empty line before access modifiers. 2400 enum EmptyLineBeforeAccessModifierStyle : int8_t { 2401 /// Remove all empty lines before access modifiers. 2402 /// \code 2403 /// struct foo { 2404 /// private: 2405 /// int i; 2406 /// protected: 2407 /// int j; 2408 /// /* comment */ 2409 /// public: 2410 /// foo() {} 2411 /// private: 2412 /// protected: 2413 /// }; 2414 /// \endcode 2415 ELBAMS_Never, 2416 /// Keep existing empty lines before access modifiers. 2417 ELBAMS_Leave, 2418 /// Add empty line only when access modifier starts a new logical block. 2419 /// Logical block is a group of one or more member fields or functions. 2420 /// \code 2421 /// struct foo { 2422 /// private: 2423 /// int i; 2424 /// 2425 /// protected: 2426 /// int j; 2427 /// /* comment */ 2428 /// public: 2429 /// foo() {} 2430 /// 2431 /// private: 2432 /// protected: 2433 /// }; 2434 /// \endcode 2435 ELBAMS_LogicalBlock, 2436 /// Always add empty line before access modifiers unless access modifier 2437 /// is at the start of struct or class definition. 2438 /// \code 2439 /// struct foo { 2440 /// private: 2441 /// int i; 2442 /// 2443 /// protected: 2444 /// int j; 2445 /// /* comment */ 2446 /// 2447 /// public: 2448 /// foo() {} 2449 /// 2450 /// private: 2451 /// 2452 /// protected: 2453 /// }; 2454 /// \endcode 2455 ELBAMS_Always, 2456 }; 2457 2458 /// Defines in which cases to put empty line before access modifiers. 2459 /// \version 12 2460 EmptyLineBeforeAccessModifierStyle EmptyLineBeforeAccessModifier; 2461 2462 /// If ``true``, clang-format detects whether function calls and 2463 /// definitions are formatted with one parameter per line. 2464 /// 2465 /// Each call can be bin-packed, one-per-line or inconclusive. If it is 2466 /// inconclusive, e.g. completely on one line, but a decision needs to be 2467 /// made, clang-format analyzes whether there are other bin-packed cases in 2468 /// the input file and act accordingly. 2469 /// 2470 /// \note 2471 /// This is an experimental flag, that might go away or be renamed. Do 2472 /// not use this in config files, etc. Use at your own risk. 2473 /// \endnote 2474 /// \version 3.7 2475 bool ExperimentalAutoDetectBinPacking; 2476 2477 /// If ``true``, clang-format adds missing namespace end comments for 2478 /// namespaces and fixes invalid existing ones. This doesn't affect short 2479 /// namespaces, which are controlled by ``ShortNamespaceLines``. 2480 /// \code 2481 /// true: false: 2482 /// namespace longNamespace { vs. namespace longNamespace { 2483 /// void foo(); void foo(); 2484 /// void bar(); void bar(); 2485 /// } // namespace a } 2486 /// namespace shortNamespace { namespace shortNamespace { 2487 /// void baz(); void baz(); 2488 /// } } 2489 /// \endcode 2490 /// \version 5 2491 bool FixNamespaceComments; 2492 2493 /// A vector of macros that should be interpreted as foreach loops 2494 /// instead of as function calls. 2495 /// 2496 /// These are expected to be macros of the form: 2497 /// \code 2498 /// FOREACH(<variable-declaration>, ...) 2499 /// <loop-body> 2500 /// \endcode 2501 /// 2502 /// In the .clang-format configuration file, this can be configured like: 2503 /// \code{.yaml} 2504 /// ForEachMacros: ['RANGES_FOR', 'FOREACH'] 2505 /// \endcode 2506 /// 2507 /// For example: BOOST_FOREACH. 2508 /// \version 3.7 2509 std::vector<std::string> ForEachMacros; 2510 2511 tooling::IncludeStyle IncludeStyle; 2512 2513 /// A vector of macros that should be interpreted as conditionals 2514 /// instead of as function calls. 2515 /// 2516 /// These are expected to be macros of the form: 2517 /// \code 2518 /// IF(...) 2519 /// <conditional-body> 2520 /// else IF(...) 2521 /// <conditional-body> 2522 /// \endcode 2523 /// 2524 /// In the .clang-format configuration file, this can be configured like: 2525 /// \code{.yaml} 2526 /// IfMacros: ['IF'] 2527 /// \endcode 2528 /// 2529 /// For example: `KJ_IF_MAYBE 2530 /// <https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#maybes>`_ 2531 /// \version 13 2532 std::vector<std::string> IfMacros; 2533 2534 /// Specify whether access modifiers should have their own indentation level. 2535 /// 2536 /// When ``false``, access modifiers are indented (or outdented) relative to 2537 /// the record members, respecting the ``AccessModifierOffset``. Record 2538 /// members are indented one level below the record. 2539 /// When ``true``, access modifiers get their own indentation level. As a 2540 /// consequence, record members are always indented 2 levels below the record, 2541 /// regardless of the access modifier presence. Value of the 2542 /// ``AccessModifierOffset`` is ignored. 2543 /// \code 2544 /// false: true: 2545 /// class C { vs. class C { 2546 /// class D { class D { 2547 /// void bar(); void bar(); 2548 /// protected: protected: 2549 /// D(); D(); 2550 /// }; }; 2551 /// public: public: 2552 /// C(); C(); 2553 /// }; }; 2554 /// void foo() { void foo() { 2555 /// return 1; return 1; 2556 /// } } 2557 /// \endcode 2558 /// \version 13 2559 bool IndentAccessModifiers; 2560 2561 /// Indent case label blocks one level from the case label. 2562 /// 2563 /// When ``false``, the block following the case label uses the same 2564 /// indentation level as for the case label, treating the case label the same 2565 /// as an if-statement. 2566 /// When ``true``, the block gets indented as a scope block. 2567 /// \code 2568 /// false: true: 2569 /// switch (fool) { vs. switch (fool) { 2570 /// case 1: { case 1: 2571 /// bar(); { 2572 /// } break; bar(); 2573 /// default: { } 2574 /// plop(); break; 2575 /// } default: 2576 /// } { 2577 /// plop(); 2578 /// } 2579 /// } 2580 /// \endcode 2581 /// \version 11 2582 bool IndentCaseBlocks; 2583 2584 /// Indent case labels one level from the switch statement. 2585 /// 2586 /// When ``false``, use the same indentation level as for the switch 2587 /// statement. Switch statement body is always indented one level more than 2588 /// case labels (except the first block following the case label, which 2589 /// itself indents the code - unless IndentCaseBlocks is enabled). 2590 /// \code 2591 /// false: true: 2592 /// switch (fool) { vs. switch (fool) { 2593 /// case 1: case 1: 2594 /// bar(); bar(); 2595 /// break; break; 2596 /// default: default: 2597 /// plop(); plop(); 2598 /// } } 2599 /// \endcode 2600 /// \version 3.3 2601 bool IndentCaseLabels; 2602 2603 /// Indent goto labels. 2604 /// 2605 /// When ``false``, goto labels are flushed left. 2606 /// \code 2607 /// true: false: 2608 /// int f() { vs. int f() { 2609 /// if (foo()) { if (foo()) { 2610 /// label1: label1: 2611 /// bar(); bar(); 2612 /// } } 2613 /// label2: label2: 2614 /// return 1; return 1; 2615 /// } } 2616 /// \endcode 2617 /// \version 10 2618 bool IndentGotoLabels; 2619 2620 /// Indents extern blocks 2621 enum IndentExternBlockStyle : int8_t { 2622 /// Backwards compatible with AfterExternBlock's indenting. 2623 /// \code 2624 /// IndentExternBlock: AfterExternBlock 2625 /// BraceWrapping.AfterExternBlock: true 2626 /// extern "C" 2627 /// { 2628 /// void foo(); 2629 /// } 2630 /// \endcode 2631 /// 2632 /// \code 2633 /// IndentExternBlock: AfterExternBlock 2634 /// BraceWrapping.AfterExternBlock: false 2635 /// extern "C" { 2636 /// void foo(); 2637 /// } 2638 /// \endcode 2639 IEBS_AfterExternBlock, 2640 /// Does not indent extern blocks. 2641 /// \code 2642 /// extern "C" { 2643 /// void foo(); 2644 /// } 2645 /// \endcode 2646 IEBS_NoIndent, 2647 /// Indents extern blocks. 2648 /// \code 2649 /// extern "C" { 2650 /// void foo(); 2651 /// } 2652 /// \endcode 2653 IEBS_Indent, 2654 }; 2655 2656 /// IndentExternBlockStyle is the type of indenting of extern blocks. 2657 /// \version 11 2658 IndentExternBlockStyle IndentExternBlock; 2659 2660 /// Options for indenting preprocessor directives. 2661 enum PPDirectiveIndentStyle : int8_t { 2662 /// Does not indent any directives. 2663 /// \code 2664 /// #if FOO 2665 /// #if BAR 2666 /// #include <foo> 2667 /// #endif 2668 /// #endif 2669 /// \endcode 2670 PPDIS_None, 2671 /// Indents directives after the hash. 2672 /// \code 2673 /// #if FOO 2674 /// # if BAR 2675 /// # include <foo> 2676 /// # endif 2677 /// #endif 2678 /// \endcode 2679 PPDIS_AfterHash, 2680 /// Indents directives before the hash. 2681 /// \code 2682 /// #if FOO 2683 /// #if BAR 2684 /// #include <foo> 2685 /// #endif 2686 /// #endif 2687 /// \endcode 2688 PPDIS_BeforeHash 2689 }; 2690 2691 /// The preprocessor directive indenting style to use. 2692 /// \version 6 2693 PPDirectiveIndentStyle IndentPPDirectives; 2694 2695 /// Indent the requires clause in a template. This only applies when 2696 /// ``RequiresClausePosition`` is ``OwnLine``, or ``WithFollowing``. 2697 /// 2698 /// In clang-format 12, 13 and 14 it was named ``IndentRequires``. 2699 /// \code 2700 /// true: 2701 /// template <typename It> 2702 /// requires Iterator<It> 2703 /// void sort(It begin, It end) { 2704 /// //.... 2705 /// } 2706 /// 2707 /// false: 2708 /// template <typename It> 2709 /// requires Iterator<It> 2710 /// void sort(It begin, It end) { 2711 /// //.... 2712 /// } 2713 /// \endcode 2714 /// \version 15 2715 bool IndentRequiresClause; 2716 2717 /// The number of columns to use for indentation. 2718 /// \code 2719 /// IndentWidth: 3 2720 /// 2721 /// void f() { 2722 /// someFunction(); 2723 /// if (true, false) { 2724 /// f(); 2725 /// } 2726 /// } 2727 /// \endcode 2728 /// \version 3.7 2729 unsigned IndentWidth; 2730 2731 /// Indent if a function definition or declaration is wrapped after the 2732 /// type. 2733 /// \code 2734 /// true: 2735 /// LoooooooooooooooooooooooooooooooooooooooongReturnType 2736 /// LoooooooooooooooooooooooooooooooongFunctionDeclaration(); 2737 /// 2738 /// false: 2739 /// LoooooooooooooooooooooooooooooooooooooooongReturnType 2740 /// LoooooooooooooooooooooooooooooooongFunctionDeclaration(); 2741 /// \endcode 2742 /// \version 3.7 2743 bool IndentWrappedFunctionNames; 2744 2745 /// Insert braces after control statements (``if``, ``else``, ``for``, ``do``, 2746 /// and ``while``) in C++ unless the control statements are inside macro 2747 /// definitions or the braces would enclose preprocessor directives. 2748 /// \warning 2749 /// Setting this option to ``true`` could lead to incorrect code formatting 2750 /// due to clang-format's lack of complete semantic information. As such, 2751 /// extra care should be taken to review code changes made by this option. 2752 /// \endwarning 2753 /// \code 2754 /// false: true: 2755 /// 2756 /// if (isa<FunctionDecl>(D)) vs. if (isa<FunctionDecl>(D)) { 2757 /// handleFunctionDecl(D); handleFunctionDecl(D); 2758 /// else if (isa<VarDecl>(D)) } else if (isa<VarDecl>(D)) { 2759 /// handleVarDecl(D); handleVarDecl(D); 2760 /// else } else { 2761 /// return; return; 2762 /// } 2763 /// 2764 /// while (i--) vs. while (i--) { 2765 /// for (auto *A : D.attrs()) for (auto *A : D.attrs()) { 2766 /// handleAttr(A); handleAttr(A); 2767 /// } 2768 /// } 2769 /// 2770 /// do vs. do { 2771 /// --i; --i; 2772 /// while (i); } while (i); 2773 /// \endcode 2774 /// \version 15 2775 bool InsertBraces; 2776 2777 /// Insert a newline at end of file if missing. 2778 /// \version 16 2779 bool InsertNewlineAtEOF; 2780 2781 /// The style of inserting trailing commas into container literals. 2782 enum TrailingCommaStyle : int8_t { 2783 /// Do not insert trailing commas. 2784 TCS_None, 2785 /// Insert trailing commas in container literals that were wrapped over 2786 /// multiple lines. Note that this is conceptually incompatible with 2787 /// bin-packing, because the trailing comma is used as an indicator 2788 /// that a container should be formatted one-per-line (i.e. not bin-packed). 2789 /// So inserting a trailing comma counteracts bin-packing. 2790 TCS_Wrapped, 2791 }; 2792 2793 /// If set to ``TCS_Wrapped`` will insert trailing commas in container 2794 /// literals (arrays and objects) that wrap across multiple lines. 2795 /// It is currently only available for JavaScript 2796 /// and disabled by default ``TCS_None``. 2797 /// ``InsertTrailingCommas`` cannot be used together with ``BinPackArguments`` 2798 /// as inserting the comma disables bin-packing. 2799 /// \code 2800 /// TSC_Wrapped: 2801 /// const someArray = [ 2802 /// aaaaaaaaaaaaaaaaaaaaaaaaaa, 2803 /// aaaaaaaaaaaaaaaaaaaaaaaaaa, 2804 /// aaaaaaaaaaaaaaaaaaaaaaaaaa, 2805 /// // ^ inserted 2806 /// ] 2807 /// \endcode 2808 /// \version 11 2809 TrailingCommaStyle InsertTrailingCommas; 2810 2811 /// Separator format of integer literals of different bases. 2812 /// 2813 /// If negative, remove separators. If ``0``, leave the literal as is. If 2814 /// positive, insert separators between digits starting from the rightmost 2815 /// digit. 2816 /// 2817 /// For example, the config below will leave separators in binary literals 2818 /// alone, insert separators in decimal literals to separate the digits into 2819 /// groups of 3, and remove separators in hexadecimal literals. 2820 /// \code 2821 /// IntegerLiteralSeparator: 2822 /// Binary: 0 2823 /// Decimal: 3 2824 /// Hex: -1 2825 /// \endcode 2826 /// 2827 /// You can also specify a minimum number of digits (``BinaryMinDigits``, 2828 /// ``DecimalMinDigits``, and ``HexMinDigits``) the integer literal must 2829 /// have in order for the separators to be inserted. 2830 struct IntegerLiteralSeparatorStyle { 2831 /// Format separators in binary literals. 2832 /// \code{.text} 2833 /// /* -1: */ b = 0b100111101101; 2834 /// /* 0: */ b = 0b10011'11'0110'1; 2835 /// /* 3: */ b = 0b100'111'101'101; 2836 /// /* 4: */ b = 0b1001'1110'1101; 2837 /// \endcode 2838 int8_t Binary; 2839 /// Format separators in binary literals with a minimum number of digits. 2840 /// \code{.text} 2841 /// // Binary: 3 2842 /// // BinaryMinDigits: 7 2843 /// b1 = 0b101101; 2844 /// b2 = 0b1'101'101; 2845 /// \endcode 2846 int8_t BinaryMinDigits; 2847 /// Format separators in decimal literals. 2848 /// \code{.text} 2849 /// /* -1: */ d = 18446744073709550592ull; 2850 /// /* 0: */ d = 184467'440737'0'95505'92ull; 2851 /// /* 3: */ d = 18'446'744'073'709'550'592ull; 2852 /// \endcode 2853 int8_t Decimal; 2854 /// Format separators in decimal literals with a minimum number of digits. 2855 /// \code{.text} 2856 /// // Decimal: 3 2857 /// // DecimalMinDigits: 5 2858 /// d1 = 2023; 2859 /// d2 = 10'000; 2860 /// \endcode 2861 int8_t DecimalMinDigits; 2862 /// Format separators in hexadecimal literals. 2863 /// \code{.text} 2864 /// /* -1: */ h = 0xDEADBEEFDEADBEEFuz; 2865 /// /* 0: */ h = 0xDEAD'BEEF'DE'AD'BEE'Fuz; 2866 /// /* 2: */ h = 0xDE'AD'BE'EF'DE'AD'BE'EFuz; 2867 /// \endcode 2868 int8_t Hex; 2869 /// Format separators in hexadecimal literals with a minimum number of 2870 /// digits. 2871 /// \code{.text} 2872 /// // Hex: 2 2873 /// // HexMinDigits: 6 2874 /// h1 = 0xABCDE; 2875 /// h2 = 0xAB'CD'EF; 2876 /// \endcode 2877 int8_t HexMinDigits; 2878 bool operator==(const IntegerLiteralSeparatorStyle &R) const { 2879 return Binary == R.Binary && BinaryMinDigits == R.BinaryMinDigits && 2880 Decimal == R.Decimal && DecimalMinDigits == R.DecimalMinDigits && 2881 Hex == R.Hex && HexMinDigits == R.HexMinDigits; 2882 } 2883 }; 2884 2885 /// Format integer literal separators (``'`` for C++ and ``_`` for C#, Java, 2886 /// and JavaScript). 2887 /// \version 16 2888 IntegerLiteralSeparatorStyle IntegerLiteralSeparator; 2889 2890 /// A vector of prefixes ordered by the desired groups for Java imports. 2891 /// 2892 /// One group's prefix can be a subset of another - the longest prefix is 2893 /// always matched. Within a group, the imports are ordered lexicographically. 2894 /// Static imports are grouped separately and follow the same group rules. 2895 /// By default, static imports are placed before non-static imports, 2896 /// but this behavior is changed by another option, 2897 /// ``SortJavaStaticImport``. 2898 /// 2899 /// In the .clang-format configuration file, this can be configured like 2900 /// in the following yaml example. This will result in imports being 2901 /// formatted as in the Java example below. 2902 /// \code{.yaml} 2903 /// JavaImportGroups: ['com.example', 'com', 'org'] 2904 /// \endcode 2905 /// 2906 /// \code{.java} 2907 /// import static com.example.function1; 2908 /// 2909 /// import static com.test.function2; 2910 /// 2911 /// import static org.example.function3; 2912 /// 2913 /// import com.example.ClassA; 2914 /// import com.example.Test; 2915 /// import com.example.a.ClassB; 2916 /// 2917 /// import com.test.ClassC; 2918 /// 2919 /// import org.example.ClassD; 2920 /// \endcode 2921 /// \version 8 2922 std::vector<std::string> JavaImportGroups; 2923 2924 /// Quotation styles for JavaScript strings. Does not affect template 2925 /// strings. 2926 enum JavaScriptQuoteStyle : int8_t { 2927 /// Leave string quotes as they are. 2928 /// \code{.js} 2929 /// string1 = "foo"; 2930 /// string2 = 'bar'; 2931 /// \endcode 2932 JSQS_Leave, 2933 /// Always use single quotes. 2934 /// \code{.js} 2935 /// string1 = 'foo'; 2936 /// string2 = 'bar'; 2937 /// \endcode 2938 JSQS_Single, 2939 /// Always use double quotes. 2940 /// \code{.js} 2941 /// string1 = "foo"; 2942 /// string2 = "bar"; 2943 /// \endcode 2944 JSQS_Double 2945 }; 2946 2947 /// The JavaScriptQuoteStyle to use for JavaScript strings. 2948 /// \version 3.9 2949 JavaScriptQuoteStyle JavaScriptQuotes; 2950 2951 // clang-format off 2952 /// Whether to wrap JavaScript import/export statements. 2953 /// \code{.js} 2954 /// true: 2955 /// import { 2956 /// VeryLongImportsAreAnnoying, 2957 /// VeryLongImportsAreAnnoying, 2958 /// VeryLongImportsAreAnnoying, 2959 /// } from 'some/module.js' 2960 /// 2961 /// false: 2962 /// import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js" 2963 /// \endcode 2964 /// \version 3.9 2965 bool JavaScriptWrapImports; 2966 // clang-format on 2967 2968 /// Keep empty lines (up to ``MaxEmptyLinesToKeep``) at end of file. 2969 /// \version 17 2970 bool KeepEmptyLinesAtEOF; 2971 2972 /// If true, the empty line at the start of blocks is kept. 2973 /// \code 2974 /// true: false: 2975 /// if (foo) { vs. if (foo) { 2976 /// bar(); 2977 /// bar(); } 2978 /// } 2979 /// \endcode 2980 /// \version 3.7 2981 bool KeepEmptyLinesAtTheStartOfBlocks; 2982 2983 /// Indentation logic for lambda bodies. 2984 enum LambdaBodyIndentationKind : int8_t { 2985 /// Align lambda body relative to the lambda signature. This is the default. 2986 /// \code 2987 /// someMethod( 2988 /// [](SomeReallyLongLambdaSignatureArgument foo) { 2989 /// return; 2990 /// }); 2991 /// \endcode 2992 LBI_Signature, 2993 /// For statements within block scope, align lambda body relative to the 2994 /// indentation level of the outer scope the lambda signature resides in. 2995 /// \code 2996 /// someMethod( 2997 /// [](SomeReallyLongLambdaSignatureArgument foo) { 2998 /// return; 2999 /// }); 3000 /// 3001 /// someMethod(someOtherMethod( 3002 /// [](SomeReallyLongLambdaSignatureArgument foo) { 3003 /// return; 3004 /// })); 3005 /// \endcode 3006 LBI_OuterScope, 3007 }; 3008 3009 /// The indentation style of lambda bodies. ``Signature`` (the default) 3010 /// causes the lambda body to be indented one additional level relative to 3011 /// the indentation level of the signature. ``OuterScope`` forces the lambda 3012 /// body to be indented one additional level relative to the parent scope 3013 /// containing the lambda signature. 3014 /// \version 13 3015 LambdaBodyIndentationKind LambdaBodyIndentation; 3016 3017 /// Supported languages. 3018 /// 3019 /// When stored in a configuration file, specifies the language, that the 3020 /// configuration targets. When passed to the ``reformat()`` function, enables 3021 /// syntax features specific to the language. 3022 enum LanguageKind : int8_t { 3023 /// Do not use. 3024 LK_None, 3025 /// Should be used for C, C++. 3026 LK_Cpp, 3027 /// Should be used for C#. 3028 LK_CSharp, 3029 /// Should be used for Java. 3030 LK_Java, 3031 /// Should be used for JavaScript. 3032 LK_JavaScript, 3033 /// Should be used for JSON. 3034 LK_Json, 3035 /// Should be used for Objective-C, Objective-C++. 3036 LK_ObjC, 3037 /// Should be used for Protocol Buffers 3038 /// (https://developers.google.com/protocol-buffers/). 3039 LK_Proto, 3040 /// Should be used for TableGen code. 3041 LK_TableGen, 3042 /// Should be used for Protocol Buffer messages in text format 3043 /// (https://developers.google.com/protocol-buffers/). 3044 LK_TextProto, 3045 /// Should be used for Verilog and SystemVerilog. 3046 /// https://standards.ieee.org/ieee/1800/6700/ 3047 /// https://sci-hub.st/10.1109/IEEESTD.2018.8299595 3048 LK_Verilog 3049 }; 3050 bool isCpp() const { return Language == LK_Cpp || Language == LK_ObjC; } 3051 bool isCSharp() const { return Language == LK_CSharp; } 3052 bool isJson() const { return Language == LK_Json; } 3053 bool isJavaScript() const { return Language == LK_JavaScript; } 3054 bool isVerilog() const { return Language == LK_Verilog; } 3055 bool isProto() const { 3056 return Language == LK_Proto || Language == LK_TextProto; 3057 } 3058 bool isTableGen() const { return Language == LK_TableGen; } 3059 3060 /// Language, this format style is targeted at. 3061 /// \version 3.5 3062 LanguageKind Language; 3063 3064 /// Line ending style. 3065 enum LineEndingStyle : int8_t { 3066 /// Use ``\n``. 3067 LE_LF, 3068 /// Use ``\r\n``. 3069 LE_CRLF, 3070 /// Use ``\n`` unless the input has more lines ending in ``\r\n``. 3071 LE_DeriveLF, 3072 /// Use ``\r\n`` unless the input has more lines ending in ``\n``. 3073 LE_DeriveCRLF, 3074 }; 3075 3076 /// Line ending style (``\n`` or ``\r\n``) to use. 3077 /// \version 16 3078 LineEndingStyle LineEnding; 3079 3080 /// A regular expression matching macros that start a block. 3081 /// \code 3082 /// # With: 3083 /// MacroBlockBegin: "^NS_MAP_BEGIN|\ 3084 /// NS_TABLE_HEAD$" 3085 /// MacroBlockEnd: "^\ 3086 /// NS_MAP_END|\ 3087 /// NS_TABLE_.*_END$" 3088 /// 3089 /// NS_MAP_BEGIN 3090 /// foo(); 3091 /// NS_MAP_END 3092 /// 3093 /// NS_TABLE_HEAD 3094 /// bar(); 3095 /// NS_TABLE_FOO_END 3096 /// 3097 /// # Without: 3098 /// NS_MAP_BEGIN 3099 /// foo(); 3100 /// NS_MAP_END 3101 /// 3102 /// NS_TABLE_HEAD 3103 /// bar(); 3104 /// NS_TABLE_FOO_END 3105 /// \endcode 3106 /// \version 3.7 3107 std::string MacroBlockBegin; 3108 3109 /// A regular expression matching macros that end a block. 3110 /// \version 3.7 3111 std::string MacroBlockEnd; 3112 3113 /// A list of macros of the form \c <definition>=<expansion> . 3114 /// 3115 /// Code will be parsed with macros expanded, in order to determine how to 3116 /// interpret and format the macro arguments. 3117 /// 3118 /// For example, the code: 3119 /// \code 3120 /// A(a*b); 3121 /// \endcode 3122 /// 3123 /// will usually be interpreted as a call to a function A, and the 3124 /// multiplication expression will be formatted as ``a * b``. 3125 /// 3126 /// If we specify the macro definition: 3127 /// \code{.yaml} 3128 /// Macros: 3129 /// - A(x)=x 3130 /// \endcode 3131 /// 3132 /// the code will now be parsed as a declaration of the variable b of type a*, 3133 /// and formatted as ``a* b`` (depending on pointer-binding rules). 3134 /// 3135 /// Features and restrictions: 3136 /// * Both function-like macros and object-like macros are supported. 3137 /// * Macro arguments must be used exactly once in the expansion. 3138 /// * No recursive expansion; macros referencing other macros will be 3139 /// ignored. 3140 /// * Overloading by arity is supported: for example, given the macro 3141 /// definitions A=x, A()=y, A(a)=a 3142 /// 3143 /// \code 3144 /// A; -> x; 3145 /// A(); -> y; 3146 /// A(z); -> z; 3147 /// A(a, b); // will not be expanded. 3148 /// \endcode 3149 /// 3150 /// \version 17 3151 std::vector<std::string> Macros; 3152 3153 /// The maximum number of consecutive empty lines to keep. 3154 /// \code 3155 /// MaxEmptyLinesToKeep: 1 vs. MaxEmptyLinesToKeep: 0 3156 /// int f() { int f() { 3157 /// int = 1; int i = 1; 3158 /// i = foo(); 3159 /// i = foo(); return i; 3160 /// } 3161 /// return i; 3162 /// } 3163 /// \endcode 3164 /// \version 3.7 3165 unsigned MaxEmptyLinesToKeep; 3166 3167 /// Different ways to indent namespace contents. 3168 enum NamespaceIndentationKind : int8_t { 3169 /// Don't indent in namespaces. 3170 /// \code 3171 /// namespace out { 3172 /// int i; 3173 /// namespace in { 3174 /// int i; 3175 /// } 3176 /// } 3177 /// \endcode 3178 NI_None, 3179 /// Indent only in inner namespaces (nested in other namespaces). 3180 /// \code 3181 /// namespace out { 3182 /// int i; 3183 /// namespace in { 3184 /// int i; 3185 /// } 3186 /// } 3187 /// \endcode 3188 NI_Inner, 3189 /// Indent in all namespaces. 3190 /// \code 3191 /// namespace out { 3192 /// int i; 3193 /// namespace in { 3194 /// int i; 3195 /// } 3196 /// } 3197 /// \endcode 3198 NI_All 3199 }; 3200 3201 /// The indentation used for namespaces. 3202 /// \version 3.7 3203 NamespaceIndentationKind NamespaceIndentation; 3204 3205 /// A vector of macros which are used to open namespace blocks. 3206 /// 3207 /// These are expected to be macros of the form: 3208 /// \code 3209 /// NAMESPACE(<namespace-name>, ...) { 3210 /// <namespace-content> 3211 /// } 3212 /// \endcode 3213 /// 3214 /// For example: TESTSUITE 3215 /// \version 9 3216 std::vector<std::string> NamespaceMacros; 3217 3218 /// Controls bin-packing Objective-C protocol conformance list 3219 /// items into as few lines as possible when they go over ``ColumnLimit``. 3220 /// 3221 /// If ``Auto`` (the default), delegates to the value in 3222 /// ``BinPackParameters``. If that is ``true``, bin-packs Objective-C 3223 /// protocol conformance list items into as few lines as possible 3224 /// whenever they go over ``ColumnLimit``. 3225 /// 3226 /// If ``Always``, always bin-packs Objective-C protocol conformance 3227 /// list items into as few lines as possible whenever they go over 3228 /// ``ColumnLimit``. 3229 /// 3230 /// If ``Never``, lays out Objective-C protocol conformance list items 3231 /// onto individual lines whenever they go over ``ColumnLimit``. 3232 /// 3233 /// \code{.objc} 3234 /// Always (or Auto, if BinPackParameters=true): 3235 /// @interface ccccccccccccc () < 3236 /// ccccccccccccc, ccccccccccccc, 3237 /// ccccccccccccc, ccccccccccccc> { 3238 /// } 3239 /// 3240 /// Never (or Auto, if BinPackParameters=false): 3241 /// @interface ddddddddddddd () < 3242 /// ddddddddddddd, 3243 /// ddddddddddddd, 3244 /// ddddddddddddd, 3245 /// ddddddddddddd> { 3246 /// } 3247 /// \endcode 3248 /// \version 7 3249 BinPackStyle ObjCBinPackProtocolList; 3250 3251 /// The number of characters to use for indentation of ObjC blocks. 3252 /// \code{.objc} 3253 /// ObjCBlockIndentWidth: 4 3254 /// 3255 /// [operation setCompletionBlock:^{ 3256 /// [self onOperationDone]; 3257 /// }]; 3258 /// \endcode 3259 /// \version 3.7 3260 unsigned ObjCBlockIndentWidth; 3261 3262 /// Break parameters list into lines when there is nested block 3263 /// parameters in a function call. 3264 /// \code 3265 /// false: 3266 /// - (void)_aMethod 3267 /// { 3268 /// [self.test1 t:self w:self callback:^(typeof(self) self, NSNumber 3269 /// *u, NSNumber *v) { 3270 /// u = c; 3271 /// }] 3272 /// } 3273 /// true: 3274 /// - (void)_aMethod 3275 /// { 3276 /// [self.test1 t:self 3277 /// w:self 3278 /// callback:^(typeof(self) self, NSNumber *u, NSNumber *v) { 3279 /// u = c; 3280 /// }] 3281 /// } 3282 /// \endcode 3283 /// \version 11 3284 bool ObjCBreakBeforeNestedBlockParam; 3285 3286 /// The order in which ObjC property attributes should appear. 3287 /// 3288 /// Attributes in code will be sorted in the order specified. Any attributes 3289 /// encountered that are not mentioned in this array will be sorted last, in 3290 /// stable order. Comments between attributes will leave the attributes 3291 /// untouched. 3292 /// \warning 3293 /// Using this option could lead to incorrect code formatting due to 3294 /// clang-format's lack of complete semantic information. As such, extra 3295 /// care should be taken to review code changes made by this option. 3296 /// \endwarning 3297 /// \code{.yaml} 3298 /// ObjCPropertyAttributeOrder: [ 3299 /// class, direct, 3300 /// atomic, nonatomic, 3301 /// assign, retain, strong, copy, weak, unsafe_unretained, 3302 /// readonly, readwrite, getter, setter, 3303 /// nullable, nonnull, null_resettable, null_unspecified 3304 /// ] 3305 /// \endcode 3306 /// \version 18 3307 std::vector<std::string> ObjCPropertyAttributeOrder; 3308 3309 /// Add a space after ``@property`` in Objective-C, i.e. use 3310 /// ``@property (readonly)`` instead of ``@property(readonly)``. 3311 /// \version 3.7 3312 bool ObjCSpaceAfterProperty; 3313 3314 /// Add a space in front of an Objective-C protocol list, i.e. use 3315 /// ``Foo <Protocol>`` instead of ``Foo<Protocol>``. 3316 /// \version 3.7 3317 bool ObjCSpaceBeforeProtocolList; 3318 3319 /// Different ways to try to fit all constructor initializers on a line. 3320 enum PackConstructorInitializersStyle : int8_t { 3321 /// Always put each constructor initializer on its own line. 3322 /// \code 3323 /// Constructor() 3324 /// : a(), 3325 /// b() 3326 /// \endcode 3327 PCIS_Never, 3328 /// Bin-pack constructor initializers. 3329 /// \code 3330 /// Constructor() 3331 /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), 3332 /// cccccccccccccccccccc() 3333 /// \endcode 3334 PCIS_BinPack, 3335 /// Put all constructor initializers on the current line if they fit. 3336 /// Otherwise, put each one on its own line. 3337 /// \code 3338 /// Constructor() : a(), b() 3339 /// 3340 /// Constructor() 3341 /// : aaaaaaaaaaaaaaaaaaaa(), 3342 /// bbbbbbbbbbbbbbbbbbbb(), 3343 /// ddddddddddddd() 3344 /// \endcode 3345 PCIS_CurrentLine, 3346 /// Same as ``PCIS_CurrentLine`` except that if all constructor initializers 3347 /// do not fit on the current line, try to fit them on the next line. 3348 /// \code 3349 /// Constructor() : a(), b() 3350 /// 3351 /// Constructor() 3352 /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd() 3353 /// 3354 /// Constructor() 3355 /// : aaaaaaaaaaaaaaaaaaaa(), 3356 /// bbbbbbbbbbbbbbbbbbbb(), 3357 /// cccccccccccccccccccc() 3358 /// \endcode 3359 PCIS_NextLine, 3360 /// Put all constructor initializers on the next line if they fit. 3361 /// Otherwise, put each one on its own line. 3362 /// \code 3363 /// Constructor() 3364 /// : a(), b() 3365 /// 3366 /// Constructor() 3367 /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd() 3368 /// 3369 /// Constructor() 3370 /// : aaaaaaaaaaaaaaaaaaaa(), 3371 /// bbbbbbbbbbbbbbbbbbbb(), 3372 /// cccccccccccccccccccc() 3373 /// \endcode 3374 PCIS_NextLineOnly, 3375 }; 3376 3377 /// The pack constructor initializers style to use. 3378 /// \version 14 3379 PackConstructorInitializersStyle PackConstructorInitializers; 3380 3381 /// The penalty for breaking around an assignment operator. 3382 /// \version 5 3383 unsigned PenaltyBreakAssignment; 3384 3385 /// The penalty for breaking a function call after ``call(``. 3386 /// \version 3.7 3387 unsigned PenaltyBreakBeforeFirstCallParameter; 3388 3389 /// The penalty for each line break introduced inside a comment. 3390 /// \version 3.7 3391 unsigned PenaltyBreakComment; 3392 3393 /// The penalty for breaking before the first ``<<``. 3394 /// \version 3.7 3395 unsigned PenaltyBreakFirstLessLess; 3396 3397 /// The penalty for breaking after ``(``. 3398 /// \version 14 3399 unsigned PenaltyBreakOpenParenthesis; 3400 3401 /// The penalty for breaking after ``::``. 3402 /// \version 18 3403 unsigned PenaltyBreakScopeResolution; 3404 3405 /// The penalty for each line break introduced inside a string literal. 3406 /// \version 3.7 3407 unsigned PenaltyBreakString; 3408 3409 /// The penalty for breaking after template declaration. 3410 /// \version 7 3411 unsigned PenaltyBreakTemplateDeclaration; 3412 3413 /// The penalty for each character outside of the column limit. 3414 /// \version 3.7 3415 unsigned PenaltyExcessCharacter; 3416 3417 /// Penalty for each character of whitespace indentation 3418 /// (counted relative to leading non-whitespace column). 3419 /// \version 12 3420 unsigned PenaltyIndentedWhitespace; 3421 3422 /// Penalty for putting the return type of a function onto its own line. 3423 /// \version 3.7 3424 unsigned PenaltyReturnTypeOnItsOwnLine; 3425 3426 /// The ``&``, ``&&`` and ``*`` alignment style. 3427 enum PointerAlignmentStyle : int8_t { 3428 /// Align pointer to the left. 3429 /// \code 3430 /// int* a; 3431 /// \endcode 3432 PAS_Left, 3433 /// Align pointer to the right. 3434 /// \code 3435 /// int *a; 3436 /// \endcode 3437 PAS_Right, 3438 /// Align pointer in the middle. 3439 /// \code 3440 /// int * a; 3441 /// \endcode 3442 PAS_Middle 3443 }; 3444 3445 /// Pointer and reference alignment style. 3446 /// \version 3.7 3447 PointerAlignmentStyle PointerAlignment; 3448 3449 /// The number of columns to use for indentation of preprocessor statements. 3450 /// When set to -1 (default) ``IndentWidth`` is used also for preprocessor 3451 /// statements. 3452 /// \code 3453 /// PPIndentWidth: 1 3454 /// 3455 /// #ifdef __linux__ 3456 /// # define FOO 3457 /// #else 3458 /// # define BAR 3459 /// #endif 3460 /// \endcode 3461 /// \version 13 3462 int PPIndentWidth; 3463 3464 /// Different specifiers and qualifiers alignment styles. 3465 enum QualifierAlignmentStyle : int8_t { 3466 /// Don't change specifiers/qualifiers to either Left or Right alignment 3467 /// (default). 3468 /// \code 3469 /// int const a; 3470 /// const int *a; 3471 /// \endcode 3472 QAS_Leave, 3473 /// Change specifiers/qualifiers to be left-aligned. 3474 /// \code 3475 /// const int a; 3476 /// const int *a; 3477 /// \endcode 3478 QAS_Left, 3479 /// Change specifiers/qualifiers to be right-aligned. 3480 /// \code 3481 /// int const a; 3482 /// int const *a; 3483 /// \endcode 3484 QAS_Right, 3485 /// Change specifiers/qualifiers to be aligned based on ``QualifierOrder``. 3486 /// With: 3487 /// \code{.yaml} 3488 /// QualifierOrder: ['inline', 'static', 'type', 'const'] 3489 /// \endcode 3490 /// 3491 /// \code 3492 /// 3493 /// int const a; 3494 /// int const *a; 3495 /// \endcode 3496 QAS_Custom 3497 }; 3498 3499 /// Different ways to arrange specifiers and qualifiers (e.g. const/volatile). 3500 /// \warning 3501 /// Setting ``QualifierAlignment`` to something other than ``Leave``, COULD 3502 /// lead to incorrect code formatting due to incorrect decisions made due to 3503 /// clang-formats lack of complete semantic information. 3504 /// As such extra care should be taken to review code changes made by the use 3505 /// of this option. 3506 /// \endwarning 3507 /// \version 14 3508 QualifierAlignmentStyle QualifierAlignment; 3509 3510 /// The order in which the qualifiers appear. 3511 /// Order is an array that can contain any of the following: 3512 /// 3513 /// * const 3514 /// * inline 3515 /// * static 3516 /// * friend 3517 /// * constexpr 3518 /// * volatile 3519 /// * restrict 3520 /// * type 3521 /// 3522 /// \note 3523 /// it MUST contain 'type'. 3524 /// \endnote 3525 /// 3526 /// Items to the left of 'type' will be placed to the left of the type and 3527 /// aligned in the order supplied. Items to the right of 'type' will be 3528 /// placed to the right of the type and aligned in the order supplied. 3529 /// 3530 /// \code{.yaml} 3531 /// QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ] 3532 /// \endcode 3533 /// \version 14 3534 std::vector<std::string> QualifierOrder; 3535 3536 /// See documentation of ``RawStringFormats``. 3537 struct RawStringFormat { 3538 /// The language of this raw string. 3539 LanguageKind Language; 3540 /// A list of raw string delimiters that match this language. 3541 std::vector<std::string> Delimiters; 3542 /// A list of enclosing function names that match this language. 3543 std::vector<std::string> EnclosingFunctions; 3544 /// The canonical delimiter for this language. 3545 std::string CanonicalDelimiter; 3546 /// The style name on which this raw string format is based on. 3547 /// If not specified, the raw string format is based on the style that this 3548 /// format is based on. 3549 std::string BasedOnStyle; 3550 bool operator==(const RawStringFormat &Other) const { 3551 return Language == Other.Language && Delimiters == Other.Delimiters && 3552 EnclosingFunctions == Other.EnclosingFunctions && 3553 CanonicalDelimiter == Other.CanonicalDelimiter && 3554 BasedOnStyle == Other.BasedOnStyle; 3555 } 3556 }; 3557 3558 /// Defines hints for detecting supported languages code blocks in raw 3559 /// strings. 3560 /// 3561 /// A raw string with a matching delimiter or a matching enclosing function 3562 /// name will be reformatted assuming the specified language based on the 3563 /// style for that language defined in the .clang-format file. If no style has 3564 /// been defined in the .clang-format file for the specific language, a 3565 /// predefined style given by 'BasedOnStyle' is used. If 'BasedOnStyle' is not 3566 /// found, the formatting is based on llvm style. A matching delimiter takes 3567 /// precedence over a matching enclosing function name for determining the 3568 /// language of the raw string contents. 3569 /// 3570 /// If a canonical delimiter is specified, occurrences of other delimiters for 3571 /// the same language will be updated to the canonical if possible. 3572 /// 3573 /// There should be at most one specification per language and each delimiter 3574 /// and enclosing function should not occur in multiple specifications. 3575 /// 3576 /// To configure this in the .clang-format file, use: 3577 /// \code{.yaml} 3578 /// RawStringFormats: 3579 /// - Language: TextProto 3580 /// Delimiters: 3581 /// - 'pb' 3582 /// - 'proto' 3583 /// EnclosingFunctions: 3584 /// - 'PARSE_TEXT_PROTO' 3585 /// BasedOnStyle: google 3586 /// - Language: Cpp 3587 /// Delimiters: 3588 /// - 'cc' 3589 /// - 'cpp' 3590 /// BasedOnStyle: llvm 3591 /// CanonicalDelimiter: 'cc' 3592 /// \endcode 3593 /// \version 6 3594 std::vector<RawStringFormat> RawStringFormats; 3595 3596 /// \brief The ``&`` and ``&&`` alignment style. 3597 enum ReferenceAlignmentStyle : int8_t { 3598 /// Align reference like ``PointerAlignment``. 3599 RAS_Pointer, 3600 /// Align reference to the left. 3601 /// \code 3602 /// int& a; 3603 /// \endcode 3604 RAS_Left, 3605 /// Align reference to the right. 3606 /// \code 3607 /// int &a; 3608 /// \endcode 3609 RAS_Right, 3610 /// Align reference in the middle. 3611 /// \code 3612 /// int & a; 3613 /// \endcode 3614 RAS_Middle 3615 }; 3616 3617 /// \brief Reference alignment style (overrides ``PointerAlignment`` for 3618 /// references). 3619 /// \version 13 3620 ReferenceAlignmentStyle ReferenceAlignment; 3621 3622 // clang-format off 3623 /// If ``true``, clang-format will attempt to re-flow comments. That is it 3624 /// will touch a comment and *reflow* long comments into new lines, trying to 3625 /// obey the ``ColumnLimit``. 3626 /// \code 3627 /// false: 3628 /// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information 3629 /// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */ 3630 /// 3631 /// true: 3632 /// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of 3633 /// // information 3634 /// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of 3635 /// * information */ 3636 /// \endcode 3637 /// \version 3.8 3638 bool ReflowComments; 3639 // clang-format on 3640 3641 /// Remove optional braces of control statements (``if``, ``else``, ``for``, 3642 /// and ``while``) in C++ according to the LLVM coding style. 3643 /// \warning 3644 /// This option will be renamed and expanded to support other styles. 3645 /// \endwarning 3646 /// \warning 3647 /// Setting this option to ``true`` could lead to incorrect code formatting 3648 /// due to clang-format's lack of complete semantic information. As such, 3649 /// extra care should be taken to review code changes made by this option. 3650 /// \endwarning 3651 /// \code 3652 /// false: true: 3653 /// 3654 /// if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D)) 3655 /// handleFunctionDecl(D); handleFunctionDecl(D); 3656 /// } else if (isa<VarDecl>(D)) { else if (isa<VarDecl>(D)) 3657 /// handleVarDecl(D); handleVarDecl(D); 3658 /// } 3659 /// 3660 /// if (isa<VarDecl>(D)) { vs. if (isa<VarDecl>(D)) { 3661 /// for (auto *A : D.attrs()) { for (auto *A : D.attrs()) 3662 /// if (shouldProcessAttr(A)) { if (shouldProcessAttr(A)) 3663 /// handleAttr(A); handleAttr(A); 3664 /// } } 3665 /// } 3666 /// } 3667 /// 3668 /// if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D)) 3669 /// for (auto *A : D.attrs()) { for (auto *A : D.attrs()) 3670 /// handleAttr(A); handleAttr(A); 3671 /// } 3672 /// } 3673 /// 3674 /// if (auto *D = (T)(D)) { vs. if (auto *D = (T)(D)) { 3675 /// if (shouldProcess(D)) { if (shouldProcess(D)) 3676 /// handleVarDecl(D); handleVarDecl(D); 3677 /// } else { else 3678 /// markAsIgnored(D); markAsIgnored(D); 3679 /// } } 3680 /// } 3681 /// 3682 /// if (a) { vs. if (a) 3683 /// b(); b(); 3684 /// } else { else if (c) 3685 /// if (c) { d(); 3686 /// d(); else 3687 /// } else { e(); 3688 /// e(); 3689 /// } 3690 /// } 3691 /// \endcode 3692 /// \version 14 3693 bool RemoveBracesLLVM; 3694 3695 /// Types of redundant parentheses to remove. 3696 enum RemoveParenthesesStyle : int8_t { 3697 /// Do not remove parentheses. 3698 /// \code 3699 /// class __declspec((dllimport)) X {}; 3700 /// co_return (((0))); 3701 /// return ((a + b) - ((c + d))); 3702 /// \endcode 3703 RPS_Leave, 3704 /// Replace multiple parentheses with single parentheses. 3705 /// \code 3706 /// class __declspec(dllimport) X {}; 3707 /// co_return (0); 3708 /// return ((a + b) - (c + d)); 3709 /// \endcode 3710 RPS_MultipleParentheses, 3711 /// Also remove parentheses enclosing the expression in a 3712 /// ``return``/``co_return`` statement. 3713 /// \code 3714 /// class __declspec(dllimport) X {}; 3715 /// co_return 0; 3716 /// return (a + b) - (c + d); 3717 /// \endcode 3718 RPS_ReturnStatement, 3719 }; 3720 3721 /// Remove redundant parentheses. 3722 /// \warning 3723 /// Setting this option to any value other than ``Leave`` could lead to 3724 /// incorrect code formatting due to clang-format's lack of complete semantic 3725 /// information. As such, extra care should be taken to review code changes 3726 /// made by this option. 3727 /// \endwarning 3728 /// \version 17 3729 RemoveParenthesesStyle RemoveParentheses; 3730 3731 /// Remove semicolons after the closing brace of a non-empty function. 3732 /// \warning 3733 /// Setting this option to ``true`` could lead to incorrect code formatting 3734 /// due to clang-format's lack of complete semantic information. As such, 3735 /// extra care should be taken to review code changes made by this option. 3736 /// \endwarning 3737 /// \code 3738 /// false: true: 3739 /// 3740 /// int max(int a, int b) { int max(int a, int b) { 3741 /// return a > b ? a : b; return a > b ? a : b; 3742 /// }; } 3743 /// 3744 /// \endcode 3745 /// \version 16 3746 bool RemoveSemicolon; 3747 3748 /// \brief The possible positions for the requires clause. The 3749 /// ``IndentRequires`` option is only used if the ``requires`` is put on the 3750 /// start of a line. 3751 enum RequiresClausePositionStyle : int8_t { 3752 /// Always put the ``requires`` clause on its own line. 3753 /// \code 3754 /// template <typename T> 3755 /// requires C<T> 3756 /// struct Foo {... 3757 /// 3758 /// template <typename T> 3759 /// requires C<T> 3760 /// void bar(T t) {... 3761 /// 3762 /// template <typename T> 3763 /// void baz(T t) 3764 /// requires C<T> 3765 /// {... 3766 /// \endcode 3767 RCPS_OwnLine, 3768 /// Try to put the clause together with the preceding part of a declaration. 3769 /// For class templates: stick to the template declaration. 3770 /// For function templates: stick to the template declaration. 3771 /// For function declaration followed by a requires clause: stick to the 3772 /// parameter list. 3773 /// \code 3774 /// template <typename T> requires C<T> 3775 /// struct Foo {... 3776 /// 3777 /// template <typename T> requires C<T> 3778 /// void bar(T t) {... 3779 /// 3780 /// template <typename T> 3781 /// void baz(T t) requires C<T> 3782 /// {... 3783 /// \endcode 3784 RCPS_WithPreceding, 3785 /// Try to put the ``requires`` clause together with the class or function 3786 /// declaration. 3787 /// \code 3788 /// template <typename T> 3789 /// requires C<T> struct Foo {... 3790 /// 3791 /// template <typename T> 3792 /// requires C<T> void bar(T t) {... 3793 /// 3794 /// template <typename T> 3795 /// void baz(T t) 3796 /// requires C<T> {... 3797 /// \endcode 3798 RCPS_WithFollowing, 3799 /// Try to put everything in the same line if possible. Otherwise normal 3800 /// line breaking rules take over. 3801 /// \code 3802 /// // Fitting: 3803 /// template <typename T> requires C<T> struct Foo {... 3804 /// 3805 /// template <typename T> requires C<T> void bar(T t) {... 3806 /// 3807 /// template <typename T> void bar(T t) requires C<T> {... 3808 /// 3809 /// // Not fitting, one possible example: 3810 /// template <typename LongName> 3811 /// requires C<LongName> 3812 /// struct Foo {... 3813 /// 3814 /// template <typename LongName> 3815 /// requires C<LongName> 3816 /// void bar(LongName ln) { 3817 /// 3818 /// template <typename LongName> 3819 /// void bar(LongName ln) 3820 /// requires C<LongName> { 3821 /// \endcode 3822 RCPS_SingleLine, 3823 }; 3824 3825 /// \brief The position of the ``requires`` clause. 3826 /// \version 15 3827 RequiresClausePositionStyle RequiresClausePosition; 3828 3829 /// Indentation logic for requires expression bodies. 3830 enum RequiresExpressionIndentationKind : int8_t { 3831 /// Align requires expression body relative to the indentation level of the 3832 /// outer scope the requires expression resides in. 3833 /// This is the default. 3834 /// \code 3835 /// template <typename T> 3836 /// concept C = requires(T t) { 3837 /// ... 3838 /// } 3839 /// \endcode 3840 REI_OuterScope, 3841 /// Align requires expression body relative to the ``requires`` keyword. 3842 /// \code 3843 /// template <typename T> 3844 /// concept C = requires(T t) { 3845 /// ... 3846 /// } 3847 /// \endcode 3848 REI_Keyword, 3849 }; 3850 3851 /// The indentation used for requires expression bodies. 3852 /// \version 16 3853 RequiresExpressionIndentationKind RequiresExpressionIndentation; 3854 3855 /// \brief The style if definition blocks should be separated. 3856 enum SeparateDefinitionStyle : int8_t { 3857 /// Leave definition blocks as they are. 3858 SDS_Leave, 3859 /// Insert an empty line between definition blocks. 3860 SDS_Always, 3861 /// Remove any empty line between definition blocks. 3862 SDS_Never 3863 }; 3864 3865 /// Specifies the use of empty lines to separate definition blocks, including 3866 /// classes, structs, enums, and functions. 3867 /// \code 3868 /// Never v.s. Always 3869 /// #include <cstring> #include <cstring> 3870 /// struct Foo { 3871 /// int a, b, c; struct Foo { 3872 /// }; int a, b, c; 3873 /// namespace Ns { }; 3874 /// class Bar { 3875 /// public: namespace Ns { 3876 /// struct Foobar { class Bar { 3877 /// int a; public: 3878 /// int b; struct Foobar { 3879 /// }; int a; 3880 /// private: int b; 3881 /// int t; }; 3882 /// int method1() { 3883 /// // ... private: 3884 /// } int t; 3885 /// enum List { 3886 /// ITEM1, int method1() { 3887 /// ITEM2 // ... 3888 /// }; } 3889 /// template<typename T> 3890 /// int method2(T x) { enum List { 3891 /// // ... ITEM1, 3892 /// } ITEM2 3893 /// int i, j, k; }; 3894 /// int method3(int par) { 3895 /// // ... template<typename T> 3896 /// } int method2(T x) { 3897 /// }; // ... 3898 /// class C {}; } 3899 /// } 3900 /// int i, j, k; 3901 /// 3902 /// int method3(int par) { 3903 /// // ... 3904 /// } 3905 /// }; 3906 /// 3907 /// class C {}; 3908 /// } 3909 /// \endcode 3910 /// \version 14 3911 SeparateDefinitionStyle SeparateDefinitionBlocks; 3912 3913 /// The maximal number of unwrapped lines that a short namespace spans. 3914 /// Defaults to 1. 3915 /// 3916 /// This determines the maximum length of short namespaces by counting 3917 /// unwrapped lines (i.e. containing neither opening nor closing 3918 /// namespace brace) and makes "FixNamespaceComments" omit adding 3919 /// end comments for those. 3920 /// \code 3921 /// ShortNamespaceLines: 1 vs. ShortNamespaceLines: 0 3922 /// namespace a { namespace a { 3923 /// int foo; int foo; 3924 /// } } // namespace a 3925 /// 3926 /// ShortNamespaceLines: 1 vs. ShortNamespaceLines: 0 3927 /// namespace b { namespace b { 3928 /// int foo; int foo; 3929 /// int bar; int bar; 3930 /// } // namespace b } // namespace b 3931 /// \endcode 3932 /// \version 13 3933 unsigned ShortNamespaceLines; 3934 3935 /// Do not format macro definition body. 3936 /// \version 18 3937 bool SkipMacroDefinitionBody; 3938 3939 /// Include sorting options. 3940 enum SortIncludesOptions : int8_t { 3941 /// Includes are never sorted. 3942 /// \code 3943 /// #include "B/A.h" 3944 /// #include "A/B.h" 3945 /// #include "a/b.h" 3946 /// #include "A/b.h" 3947 /// #include "B/a.h" 3948 /// \endcode 3949 SI_Never, 3950 /// Includes are sorted in an ASCIIbetical or case sensitive fashion. 3951 /// \code 3952 /// #include "A/B.h" 3953 /// #include "A/b.h" 3954 /// #include "B/A.h" 3955 /// #include "B/a.h" 3956 /// #include "a/b.h" 3957 /// \endcode 3958 SI_CaseSensitive, 3959 /// Includes are sorted in an alphabetical or case insensitive fashion. 3960 /// \code 3961 /// #include "A/B.h" 3962 /// #include "A/b.h" 3963 /// #include "a/b.h" 3964 /// #include "B/A.h" 3965 /// #include "B/a.h" 3966 /// \endcode 3967 SI_CaseInsensitive, 3968 }; 3969 3970 /// Controls if and how clang-format will sort ``#includes``. 3971 /// \version 3.8 3972 SortIncludesOptions SortIncludes; 3973 3974 /// Position for Java Static imports. 3975 enum SortJavaStaticImportOptions : int8_t { 3976 /// Static imports are placed before non-static imports. 3977 /// \code{.java} 3978 /// import static org.example.function1; 3979 /// 3980 /// import org.example.ClassA; 3981 /// \endcode 3982 SJSIO_Before, 3983 /// Static imports are placed after non-static imports. 3984 /// \code{.java} 3985 /// import org.example.ClassA; 3986 /// 3987 /// import static org.example.function1; 3988 /// \endcode 3989 SJSIO_After, 3990 }; 3991 3992 /// When sorting Java imports, by default static imports are placed before 3993 /// non-static imports. If ``JavaStaticImportAfterImport`` is ``After``, 3994 /// static imports are placed after non-static imports. 3995 /// \version 12 3996 SortJavaStaticImportOptions SortJavaStaticImport; 3997 3998 /// Using declaration sorting options. 3999 enum SortUsingDeclarationsOptions : int8_t { 4000 /// Using declarations are never sorted. 4001 /// \code 4002 /// using std::chrono::duration_cast; 4003 /// using std::move; 4004 /// using boost::regex; 4005 /// using boost::regex_constants::icase; 4006 /// using std::string; 4007 /// \endcode 4008 SUD_Never, 4009 /// Using declarations are sorted in the order defined as follows: 4010 /// Split the strings by "::" and discard any initial empty strings. Sort 4011 /// the lists of names lexicographically, and within those groups, names are 4012 /// in case-insensitive lexicographic order. 4013 /// \code 4014 /// using boost::regex; 4015 /// using boost::regex_constants::icase; 4016 /// using std::chrono::duration_cast; 4017 /// using std::move; 4018 /// using std::string; 4019 /// \endcode 4020 SUD_Lexicographic, 4021 /// Using declarations are sorted in the order defined as follows: 4022 /// Split the strings by "::" and discard any initial empty strings. The 4023 /// last element of each list is a non-namespace name; all others are 4024 /// namespace names. Sort the lists of names lexicographically, where the 4025 /// sort order of individual names is that all non-namespace names come 4026 /// before all namespace names, and within those groups, names are in 4027 /// case-insensitive lexicographic order. 4028 /// \code 4029 /// using boost::regex; 4030 /// using boost::regex_constants::icase; 4031 /// using std::move; 4032 /// using std::string; 4033 /// using std::chrono::duration_cast; 4034 /// \endcode 4035 SUD_LexicographicNumeric, 4036 }; 4037 4038 /// Controls if and how clang-format will sort using declarations. 4039 /// \version 5 4040 SortUsingDeclarationsOptions SortUsingDeclarations; 4041 4042 /// If ``true``, a space is inserted after C style casts. 4043 /// \code 4044 /// true: false: 4045 /// (int) i; vs. (int)i; 4046 /// \endcode 4047 /// \version 3.5 4048 bool SpaceAfterCStyleCast; 4049 4050 /// If ``true``, a space is inserted after the logical not operator (``!``). 4051 /// \code 4052 /// true: false: 4053 /// ! someExpression(); vs. !someExpression(); 4054 /// \endcode 4055 /// \version 9 4056 bool SpaceAfterLogicalNot; 4057 4058 /// If \c true, a space will be inserted after the 'template' keyword. 4059 /// \code 4060 /// true: false: 4061 /// template <int> void foo(); vs. template<int> void foo(); 4062 /// \endcode 4063 /// \version 4 4064 bool SpaceAfterTemplateKeyword; 4065 4066 /// Different ways to put a space before opening parentheses. 4067 enum SpaceAroundPointerQualifiersStyle : int8_t { 4068 /// Don't ensure spaces around pointer qualifiers and use PointerAlignment 4069 /// instead. 4070 /// \code 4071 /// PointerAlignment: Left PointerAlignment: Right 4072 /// void* const* x = NULL; vs. void *const *x = NULL; 4073 /// \endcode 4074 SAPQ_Default, 4075 /// Ensure that there is a space before pointer qualifiers. 4076 /// \code 4077 /// PointerAlignment: Left PointerAlignment: Right 4078 /// void* const* x = NULL; vs. void * const *x = NULL; 4079 /// \endcode 4080 SAPQ_Before, 4081 /// Ensure that there is a space after pointer qualifiers. 4082 /// \code 4083 /// PointerAlignment: Left PointerAlignment: Right 4084 /// void* const * x = NULL; vs. void *const *x = NULL; 4085 /// \endcode 4086 SAPQ_After, 4087 /// Ensure that there is a space both before and after pointer qualifiers. 4088 /// \code 4089 /// PointerAlignment: Left PointerAlignment: Right 4090 /// void* const * x = NULL; vs. void * const *x = NULL; 4091 /// \endcode 4092 SAPQ_Both, 4093 }; 4094 4095 /// Defines in which cases to put a space before or after pointer qualifiers 4096 /// \version 12 4097 SpaceAroundPointerQualifiersStyle SpaceAroundPointerQualifiers; 4098 4099 /// If ``false``, spaces will be removed before assignment operators. 4100 /// \code 4101 /// true: false: 4102 /// int a = 5; vs. int a= 5; 4103 /// a += 42; a+= 42; 4104 /// \endcode 4105 /// \version 3.7 4106 bool SpaceBeforeAssignmentOperators; 4107 4108 /// If ``false``, spaces will be removed before case colon. 4109 /// \code 4110 /// true: false 4111 /// switch (x) { vs. switch (x) { 4112 /// case 1 : break; case 1: break; 4113 /// } } 4114 /// \endcode 4115 /// \version 12 4116 bool SpaceBeforeCaseColon; 4117 4118 /// If ``true``, a space will be inserted before a C++11 braced list 4119 /// used to initialize an object (after the preceding identifier or type). 4120 /// \code 4121 /// true: false: 4122 /// Foo foo { bar }; vs. Foo foo{ bar }; 4123 /// Foo {}; Foo{}; 4124 /// vector<int> { 1, 2, 3 }; vector<int>{ 1, 2, 3 }; 4125 /// new int[3] { 1, 2, 3 }; new int[3]{ 1, 2, 3 }; 4126 /// \endcode 4127 /// \version 7 4128 bool SpaceBeforeCpp11BracedList; 4129 4130 /// If ``false``, spaces will be removed before constructor initializer 4131 /// colon. 4132 /// \code 4133 /// true: false: 4134 /// Foo::Foo() : a(a) {} Foo::Foo(): a(a) {} 4135 /// \endcode 4136 /// \version 7 4137 bool SpaceBeforeCtorInitializerColon; 4138 4139 /// If ``false``, spaces will be removed before inheritance colon. 4140 /// \code 4141 /// true: false: 4142 /// class Foo : Bar {} vs. class Foo: Bar {} 4143 /// \endcode 4144 /// \version 7 4145 bool SpaceBeforeInheritanceColon; 4146 4147 /// If ``true``, a space will be added before a JSON colon. For other 4148 /// languages, e.g. JavaScript, use ``SpacesInContainerLiterals`` instead. 4149 /// \code 4150 /// true: false: 4151 /// { { 4152 /// "key" : "value" vs. "key": "value" 4153 /// } } 4154 /// \endcode 4155 /// \version 17 4156 bool SpaceBeforeJsonColon; 4157 4158 /// Different ways to put a space before opening parentheses. 4159 enum SpaceBeforeParensStyle : int8_t { 4160 /// This is **deprecated** and replaced by ``Custom`` below, with all 4161 /// ``SpaceBeforeParensOptions`` but ``AfterPlacementOperator`` set to 4162 /// ``false``. 4163 SBPO_Never, 4164 /// Put a space before opening parentheses only after control statement 4165 /// keywords (``for/if/while...``). 4166 /// \code 4167 /// void f() { 4168 /// if (true) { 4169 /// f(); 4170 /// } 4171 /// } 4172 /// \endcode 4173 SBPO_ControlStatements, 4174 /// Same as ``SBPO_ControlStatements`` except this option doesn't apply to 4175 /// ForEach and If macros. This is useful in projects where ForEach/If 4176 /// macros are treated as function calls instead of control statements. 4177 /// ``SBPO_ControlStatementsExceptForEachMacros`` remains an alias for 4178 /// backward compatibility. 4179 /// \code 4180 /// void f() { 4181 /// Q_FOREACH(...) { 4182 /// f(); 4183 /// } 4184 /// } 4185 /// \endcode 4186 SBPO_ControlStatementsExceptControlMacros, 4187 /// Put a space before opening parentheses only if the parentheses are not 4188 /// empty i.e. '()' 4189 /// \code 4190 /// void() { 4191 /// if (true) { 4192 /// f(); 4193 /// g (x, y, z); 4194 /// } 4195 /// } 4196 /// \endcode 4197 SBPO_NonEmptyParentheses, 4198 /// Always put a space before opening parentheses, except when it's 4199 /// prohibited by the syntax rules (in function-like macro definitions) or 4200 /// when determined by other style rules (after unary operators, opening 4201 /// parentheses, etc.) 4202 /// \code 4203 /// void f () { 4204 /// if (true) { 4205 /// f (); 4206 /// } 4207 /// } 4208 /// \endcode 4209 SBPO_Always, 4210 /// Configure each individual space before parentheses in 4211 /// ``SpaceBeforeParensOptions``. 4212 SBPO_Custom, 4213 }; 4214 4215 /// Defines in which cases to put a space before opening parentheses. 4216 /// \version 3.5 4217 SpaceBeforeParensStyle SpaceBeforeParens; 4218 4219 /// Precise control over the spacing before parentheses. 4220 /// \code 4221 /// # Should be declared this way: 4222 /// SpaceBeforeParens: Custom 4223 /// SpaceBeforeParensOptions: 4224 /// AfterControlStatements: true 4225 /// AfterFunctionDefinitionName: true 4226 /// \endcode 4227 struct SpaceBeforeParensCustom { 4228 /// If ``true``, put space between control statement keywords 4229 /// (for/if/while...) and opening parentheses. 4230 /// \code 4231 /// true: false: 4232 /// if (...) {} vs. if(...) {} 4233 /// \endcode 4234 bool AfterControlStatements; 4235 /// If ``true``, put space between foreach macros and opening parentheses. 4236 /// \code 4237 /// true: false: 4238 /// FOREACH (...) vs. FOREACH(...) 4239 /// <loop-body> <loop-body> 4240 /// \endcode 4241 bool AfterForeachMacros; 4242 /// If ``true``, put a space between function declaration name and opening 4243 /// parentheses. 4244 /// \code 4245 /// true: false: 4246 /// void f (); vs. void f(); 4247 /// \endcode 4248 bool AfterFunctionDeclarationName; 4249 /// If ``true``, put a space between function definition name and opening 4250 /// parentheses. 4251 /// \code 4252 /// true: false: 4253 /// void f () {} vs. void f() {} 4254 /// \endcode 4255 bool AfterFunctionDefinitionName; 4256 /// If ``true``, put space between if macros and opening parentheses. 4257 /// \code 4258 /// true: false: 4259 /// IF (...) vs. IF(...) 4260 /// <conditional-body> <conditional-body> 4261 /// \endcode 4262 bool AfterIfMacros; 4263 /// If ``true``, put a space between operator overloading and opening 4264 /// parentheses. 4265 /// \code 4266 /// true: false: 4267 /// void operator++ (int a); vs. void operator++(int a); 4268 /// object.operator++ (10); object.operator++(10); 4269 /// \endcode 4270 bool AfterOverloadedOperator; 4271 /// If ``true``, put a space between operator ``new``/``delete`` and opening 4272 /// parenthesis. 4273 /// \code 4274 /// true: false: 4275 /// new (buf) T; vs. new(buf) T; 4276 /// delete (buf) T; delete(buf) T; 4277 /// \endcode 4278 bool AfterPlacementOperator; 4279 /// If ``true``, put space between requires keyword in a requires clause and 4280 /// opening parentheses, if there is one. 4281 /// \code 4282 /// true: false: 4283 /// template<typename T> vs. template<typename T> 4284 /// requires (A<T> && B<T>) requires(A<T> && B<T>) 4285 /// ... ... 4286 /// \endcode 4287 bool AfterRequiresInClause; 4288 /// If ``true``, put space between requires keyword in a requires expression 4289 /// and opening parentheses. 4290 /// \code 4291 /// true: false: 4292 /// template<typename T> vs. template<typename T> 4293 /// concept C = requires (T t) { concept C = requires(T t) { 4294 /// ... ... 4295 /// } } 4296 /// \endcode 4297 bool AfterRequiresInExpression; 4298 /// If ``true``, put a space before opening parentheses only if the 4299 /// parentheses are not empty. 4300 /// \code 4301 /// true: false: 4302 /// void f (int a); vs. void f(); 4303 /// f (a); f(); 4304 /// \endcode 4305 bool BeforeNonEmptyParentheses; 4306 4307 SpaceBeforeParensCustom() 4308 : AfterControlStatements(false), AfterForeachMacros(false), 4309 AfterFunctionDeclarationName(false), 4310 AfterFunctionDefinitionName(false), AfterIfMacros(false), 4311 AfterOverloadedOperator(false), AfterPlacementOperator(true), 4312 AfterRequiresInClause(false), AfterRequiresInExpression(false), 4313 BeforeNonEmptyParentheses(false) {} 4314 4315 bool operator==(const SpaceBeforeParensCustom &Other) const { 4316 return AfterControlStatements == Other.AfterControlStatements && 4317 AfterForeachMacros == Other.AfterForeachMacros && 4318 AfterFunctionDeclarationName == 4319 Other.AfterFunctionDeclarationName && 4320 AfterFunctionDefinitionName == Other.AfterFunctionDefinitionName && 4321 AfterIfMacros == Other.AfterIfMacros && 4322 AfterOverloadedOperator == Other.AfterOverloadedOperator && 4323 AfterPlacementOperator == Other.AfterPlacementOperator && 4324 AfterRequiresInClause == Other.AfterRequiresInClause && 4325 AfterRequiresInExpression == Other.AfterRequiresInExpression && 4326 BeforeNonEmptyParentheses == Other.BeforeNonEmptyParentheses; 4327 } 4328 }; 4329 4330 /// Control of individual space before parentheses. 4331 /// 4332 /// If ``SpaceBeforeParens`` is set to ``Custom``, use this to specify 4333 /// how each individual space before parentheses case should be handled. 4334 /// Otherwise, this is ignored. 4335 /// \code{.yaml} 4336 /// # Example of usage: 4337 /// SpaceBeforeParens: Custom 4338 /// SpaceBeforeParensOptions: 4339 /// AfterControlStatements: true 4340 /// AfterFunctionDefinitionName: true 4341 /// \endcode 4342 /// \version 14 4343 SpaceBeforeParensCustom SpaceBeforeParensOptions; 4344 4345 /// If ``true``, spaces will be before ``[``. 4346 /// Lambdas will not be affected. Only the first ``[`` will get a space added. 4347 /// \code 4348 /// true: false: 4349 /// int a [5]; vs. int a[5]; 4350 /// int a [5][5]; vs. int a[5][5]; 4351 /// \endcode 4352 /// \version 10 4353 bool SpaceBeforeSquareBrackets; 4354 4355 /// If ``false``, spaces will be removed before range-based for loop 4356 /// colon. 4357 /// \code 4358 /// true: false: 4359 /// for (auto v : values) {} vs. for(auto v: values) {} 4360 /// \endcode 4361 /// \version 7 4362 bool SpaceBeforeRangeBasedForLoopColon; 4363 4364 /// If ``true``, spaces will be inserted into ``{}``. 4365 /// \code 4366 /// true: false: 4367 /// void f() { } vs. void f() {} 4368 /// while (true) { } while (true) {} 4369 /// \endcode 4370 /// \version 10 4371 bool SpaceInEmptyBlock; 4372 4373 /// If ``true``, spaces may be inserted into ``()``. 4374 /// This option is **deprecated**. See ``InEmptyParentheses`` of 4375 /// ``SpacesInParensOptions``. 4376 /// \version 3.7 4377 // bool SpaceInEmptyParentheses; 4378 4379 /// The number of spaces before trailing line comments 4380 /// (``//`` - comments). 4381 /// 4382 /// This does not affect trailing block comments (``/*`` - comments) as those 4383 /// commonly have different usage patterns and a number of special cases. In 4384 /// the case of Verilog, it doesn't affect a comment right after the opening 4385 /// parenthesis in the port or parameter list in a module header, because it 4386 /// is probably for the port on the following line instead of the parenthesis 4387 /// it follows. 4388 /// \code 4389 /// SpacesBeforeTrailingComments: 3 4390 /// void f() { 4391 /// if (true) { // foo1 4392 /// f(); // bar 4393 /// } // foo 4394 /// } 4395 /// \endcode 4396 /// \version 3.7 4397 unsigned SpacesBeforeTrailingComments; 4398 4399 /// Styles for adding spacing after ``<`` and before ``>`` 4400 /// in template argument lists. 4401 enum SpacesInAnglesStyle : int8_t { 4402 /// Remove spaces after ``<`` and before ``>``. 4403 /// \code 4404 /// static_cast<int>(arg); 4405 /// std::function<void(int)> fct; 4406 /// \endcode 4407 SIAS_Never, 4408 /// Add spaces after ``<`` and before ``>``. 4409 /// \code 4410 /// static_cast< int >(arg); 4411 /// std::function< void(int) > fct; 4412 /// \endcode 4413 SIAS_Always, 4414 /// Keep a single space after ``<`` and before ``>`` if any spaces were 4415 /// present. Option ``Standard: Cpp03`` takes precedence. 4416 SIAS_Leave 4417 }; 4418 /// The SpacesInAnglesStyle to use for template argument lists. 4419 /// \version 3.4 4420 SpacesInAnglesStyle SpacesInAngles; 4421 4422 /// If ``true``, spaces will be inserted around if/for/switch/while 4423 /// conditions. 4424 /// This option is **deprecated**. See ``InConditionalStatements`` of 4425 /// ``SpacesInParensOptions``. 4426 /// \version 10 4427 // bool SpacesInConditionalStatement; 4428 4429 /// If ``true``, spaces are inserted inside container literals (e.g. ObjC and 4430 /// Javascript array and dict literals). For JSON, use 4431 /// ``SpaceBeforeJsonColon`` instead. 4432 /// \code{.js} 4433 /// true: false: 4434 /// var arr = [ 1, 2, 3 ]; vs. var arr = [1, 2, 3]; 4435 /// f({a : 1, b : 2, c : 3}); f({a: 1, b: 2, c: 3}); 4436 /// \endcode 4437 /// \version 3.7 4438 bool SpacesInContainerLiterals; 4439 4440 /// If ``true``, spaces may be inserted into C style casts. 4441 /// This option is **deprecated**. See ``InCStyleCasts`` of 4442 /// ``SpacesInParensOptions``. 4443 /// \version 3.7 4444 // bool SpacesInCStyleCastParentheses; 4445 4446 /// Control of spaces within a single line comment. 4447 struct SpacesInLineComment { 4448 /// The minimum number of spaces at the start of the comment. 4449 unsigned Minimum; 4450 /// The maximum number of spaces at the start of the comment. 4451 unsigned Maximum; 4452 }; 4453 4454 /// How many spaces are allowed at the start of a line comment. To disable the 4455 /// maximum set it to ``-1``, apart from that the maximum takes precedence 4456 /// over the minimum. 4457 /// \code 4458 /// Minimum = 1 4459 /// Maximum = -1 4460 /// // One space is forced 4461 /// 4462 /// // but more spaces are possible 4463 /// 4464 /// Minimum = 0 4465 /// Maximum = 0 4466 /// //Forces to start every comment directly after the slashes 4467 /// \endcode 4468 /// 4469 /// Note that in line comment sections the relative indent of the subsequent 4470 /// lines is kept, that means the following: 4471 /// \code 4472 /// before: after: 4473 /// Minimum: 1 4474 /// //if (b) { // if (b) { 4475 /// // return true; // return true; 4476 /// //} // } 4477 /// 4478 /// Maximum: 0 4479 /// /// List: ///List: 4480 /// /// - Foo /// - Foo 4481 /// /// - Bar /// - Bar 4482 /// \endcode 4483 /// 4484 /// This option has only effect if ``ReflowComments`` is set to ``true``. 4485 /// \version 13 4486 SpacesInLineComment SpacesInLineCommentPrefix; 4487 4488 /// Different ways to put a space before opening and closing parentheses. 4489 enum SpacesInParensStyle : int8_t { 4490 /// Never put a space in parentheses. 4491 /// \code 4492 /// void f() { 4493 /// if(true) { 4494 /// f(); 4495 /// } 4496 /// } 4497 /// \endcode 4498 SIPO_Never, 4499 /// Configure each individual space in parentheses in 4500 /// `SpacesInParensOptions`. 4501 SIPO_Custom, 4502 }; 4503 4504 /// If ``true``, spaces will be inserted after ``(`` and before ``)``. 4505 /// This option is **deprecated**. The previous behavior is preserved by using 4506 /// ``SpacesInParens`` with ``Custom`` and by setting all 4507 /// ``SpacesInParensOptions`` to ``true`` except for ``InCStyleCasts`` and 4508 /// ``InEmptyParentheses``. 4509 /// \version 3.7 4510 // bool SpacesInParentheses; 4511 4512 /// Defines in which cases spaces will be inserted after ``(`` and before 4513 /// ``)``. 4514 /// \version 17 4515 SpacesInParensStyle SpacesInParens; 4516 4517 /// Precise control over the spacing in parentheses. 4518 /// \code 4519 /// # Should be declared this way: 4520 /// SpacesInParens: Custom 4521 /// SpacesInParensOptions: 4522 /// InConditionalStatements: true 4523 /// Other: true 4524 /// \endcode 4525 struct SpacesInParensCustom { 4526 /// Put a space in parentheses only inside conditional statements 4527 /// (``for/if/while/switch...``). 4528 /// \code 4529 /// true: false: 4530 /// if ( a ) { ... } vs. if (a) { ... } 4531 /// while ( i < 5 ) { ... } while (i < 5) { ... } 4532 /// \endcode 4533 bool InConditionalStatements; 4534 /// Put a space in C style casts. 4535 /// \code 4536 /// true: false: 4537 /// x = ( int32 )y vs. x = (int32)y 4538 /// \endcode 4539 bool InCStyleCasts; 4540 /// Put a space in parentheses only if the parentheses are empty i.e. '()' 4541 /// \code 4542 /// true: false: 4543 /// void f( ) { vs. void f() { 4544 /// int x[] = {foo( ), bar( )}; int x[] = {foo(), bar()}; 4545 /// if (true) { if (true) { 4546 /// f( ); f(); 4547 /// } } 4548 /// } } 4549 /// \endcode 4550 bool InEmptyParentheses; 4551 /// Put a space in parentheses not covered by preceding options. 4552 /// \code 4553 /// true: false: 4554 /// t f( Deleted & ) & = delete; vs. t f(Deleted &) & = delete; 4555 /// \endcode 4556 bool Other; 4557 4558 SpacesInParensCustom() 4559 : InConditionalStatements(false), InCStyleCasts(false), 4560 InEmptyParentheses(false), Other(false) {} 4561 4562 SpacesInParensCustom(bool InConditionalStatements, bool InCStyleCasts, 4563 bool InEmptyParentheses, bool Other) 4564 : InConditionalStatements(InConditionalStatements), 4565 InCStyleCasts(InCStyleCasts), InEmptyParentheses(InEmptyParentheses), 4566 Other(Other) {} 4567 4568 bool operator==(const SpacesInParensCustom &R) const { 4569 return InConditionalStatements == R.InConditionalStatements && 4570 InCStyleCasts == R.InCStyleCasts && 4571 InEmptyParentheses == R.InEmptyParentheses && Other == R.Other; 4572 } 4573 bool operator!=(const SpacesInParensCustom &R) const { 4574 return !(*this == R); 4575 } 4576 }; 4577 4578 /// Control of individual spaces in parentheses. 4579 /// 4580 /// If ``SpacesInParens`` is set to ``Custom``, use this to specify 4581 /// how each individual space in parentheses case should be handled. 4582 /// Otherwise, this is ignored. 4583 /// \code{.yaml} 4584 /// # Example of usage: 4585 /// SpacesInParens: Custom 4586 /// SpacesInParensOptions: 4587 /// InConditionalStatements: true 4588 /// InEmptyParentheses: true 4589 /// \endcode 4590 /// \version 17 4591 SpacesInParensCustom SpacesInParensOptions; 4592 4593 /// If ``true``, spaces will be inserted after ``[`` and before ``]``. 4594 /// Lambdas without arguments or unspecified size array declarations will not 4595 /// be affected. 4596 /// \code 4597 /// true: false: 4598 /// int a[ 5 ]; vs. int a[5]; 4599 /// std::unique_ptr<int[]> foo() {} // Won't be affected 4600 /// \endcode 4601 /// \version 3.7 4602 bool SpacesInSquareBrackets; 4603 4604 /// Supported language standards for parsing and formatting C++ constructs. 4605 /// \code 4606 /// Latest: vector<set<int>> 4607 /// c++03 vs. vector<set<int> > 4608 /// \endcode 4609 /// 4610 /// The correct way to spell a specific language version is e.g. ``c++11``. 4611 /// The historical aliases ``Cpp03`` and ``Cpp11`` are deprecated. 4612 enum LanguageStandard : int8_t { 4613 /// Parse and format as C++03. 4614 /// ``Cpp03`` is a deprecated alias for ``c++03`` 4615 LS_Cpp03, // c++03 4616 /// Parse and format as C++11. 4617 LS_Cpp11, // c++11 4618 /// Parse and format as C++14. 4619 LS_Cpp14, // c++14 4620 /// Parse and format as C++17. 4621 LS_Cpp17, // c++17 4622 /// Parse and format as C++20. 4623 LS_Cpp20, // c++20 4624 /// Parse and format using the latest supported language version. 4625 /// ``Cpp11`` is a deprecated alias for ``Latest`` 4626 LS_Latest, 4627 /// Automatic detection based on the input. 4628 LS_Auto, 4629 }; 4630 4631 /// Parse and format C++ constructs compatible with this standard. 4632 /// \code 4633 /// c++03: latest: 4634 /// vector<set<int> > x; vs. vector<set<int>> x; 4635 /// \endcode 4636 /// \version 3.7 4637 LanguageStandard Standard; 4638 4639 /// Macros which are ignored in front of a statement, as if they were an 4640 /// attribute. So that they are not parsed as identifier, for example for Qts 4641 /// emit. 4642 /// \code 4643 /// AlignConsecutiveDeclarations: true 4644 /// StatementAttributeLikeMacros: [] 4645 /// unsigned char data = 'x'; 4646 /// emit signal(data); // This is parsed as variable declaration. 4647 /// 4648 /// AlignConsecutiveDeclarations: true 4649 /// StatementAttributeLikeMacros: [emit] 4650 /// unsigned char data = 'x'; 4651 /// emit signal(data); // Now it's fine again. 4652 /// \endcode 4653 /// \version 12 4654 std::vector<std::string> StatementAttributeLikeMacros; 4655 4656 /// A vector of macros that should be interpreted as complete 4657 /// statements. 4658 /// 4659 /// Typical macros are expressions, and require a semi-colon to be 4660 /// added; sometimes this is not the case, and this allows to make 4661 /// clang-format aware of such cases. 4662 /// 4663 /// For example: Q_UNUSED 4664 /// \version 8 4665 std::vector<std::string> StatementMacros; 4666 4667 /// The number of columns used for tab stops. 4668 /// \version 3.7 4669 unsigned TabWidth; 4670 4671 /// A vector of non-keyword identifiers that should be interpreted as type 4672 /// names. 4673 /// 4674 /// A ``*``, ``&``, or ``&&`` between a type name and another non-keyword 4675 /// identifier is annotated as a pointer or reference token instead of a 4676 /// binary operator. 4677 /// 4678 /// \version 17 4679 std::vector<std::string> TypeNames; 4680 4681 /// \brief A vector of macros that should be interpreted as type declarations 4682 /// instead of as function calls. 4683 /// 4684 /// These are expected to be macros of the form: 4685 /// \code 4686 /// STACK_OF(...) 4687 /// \endcode 4688 /// 4689 /// In the .clang-format configuration file, this can be configured like: 4690 /// \code{.yaml} 4691 /// TypenameMacros: ['STACK_OF', 'LIST'] 4692 /// \endcode 4693 /// 4694 /// For example: OpenSSL STACK_OF, BSD LIST_ENTRY. 4695 /// \version 9 4696 std::vector<std::string> TypenameMacros; 4697 4698 /// This option is **deprecated**. See ``LF`` and ``CRLF`` of ``LineEnding``. 4699 /// \version 10 4700 // bool UseCRLF; 4701 4702 /// Different ways to use tab in formatting. 4703 enum UseTabStyle : int8_t { 4704 /// Never use tab. 4705 UT_Never, 4706 /// Use tabs only for indentation. 4707 UT_ForIndentation, 4708 /// Fill all leading whitespace with tabs, and use spaces for alignment that 4709 /// appears within a line (e.g. consecutive assignments and declarations). 4710 UT_ForContinuationAndIndentation, 4711 /// Use tabs for line continuation and indentation, and spaces for 4712 /// alignment. 4713 UT_AlignWithSpaces, 4714 /// Use tabs whenever we need to fill whitespace that spans at least from 4715 /// one tab stop to the next one. 4716 UT_Always 4717 }; 4718 4719 /// The way to use tab characters in the resulting file. 4720 /// \version 3.7 4721 UseTabStyle UseTab; 4722 4723 /// For Verilog, put each port on its own line in module instantiations. 4724 /// \code 4725 /// true: 4726 /// ffnand ff1(.q(), 4727 /// .qbar(out1), 4728 /// .clear(in1), 4729 /// .preset(in2)); 4730 /// 4731 /// false: 4732 /// ffnand ff1(.q(), .qbar(out1), .clear(in1), .preset(in2)); 4733 /// \endcode 4734 /// \version 17 4735 bool VerilogBreakBetweenInstancePorts; 4736 4737 /// A vector of macros which are whitespace-sensitive and should not 4738 /// be touched. 4739 /// 4740 /// These are expected to be macros of the form: 4741 /// \code 4742 /// STRINGIZE(...) 4743 /// \endcode 4744 /// 4745 /// In the .clang-format configuration file, this can be configured like: 4746 /// \code{.yaml} 4747 /// WhitespaceSensitiveMacros: ['STRINGIZE', 'PP_STRINGIZE'] 4748 /// \endcode 4749 /// 4750 /// For example: BOOST_PP_STRINGIZE 4751 /// \version 11 4752 std::vector<std::string> WhitespaceSensitiveMacros; 4753 4754 bool operator==(const FormatStyle &R) const { 4755 return AccessModifierOffset == R.AccessModifierOffset && 4756 AlignAfterOpenBracket == R.AlignAfterOpenBracket && 4757 AlignArrayOfStructures == R.AlignArrayOfStructures && 4758 AlignConsecutiveAssignments == R.AlignConsecutiveAssignments && 4759 AlignConsecutiveBitFields == R.AlignConsecutiveBitFields && 4760 AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations && 4761 AlignConsecutiveMacros == R.AlignConsecutiveMacros && 4762 AlignConsecutiveShortCaseStatements == 4763 R.AlignConsecutiveShortCaseStatements && 4764 AlignEscapedNewlines == R.AlignEscapedNewlines && 4765 AlignOperands == R.AlignOperands && 4766 AlignTrailingComments == R.AlignTrailingComments && 4767 AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine && 4768 AllowAllParametersOfDeclarationOnNextLine == 4769 R.AllowAllParametersOfDeclarationOnNextLine && 4770 AllowBreakBeforeNoexceptSpecifier == 4771 R.AllowBreakBeforeNoexceptSpecifier && 4772 AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine && 4773 AllowShortCaseLabelsOnASingleLine == 4774 R.AllowShortCaseLabelsOnASingleLine && 4775 AllowShortCompoundRequirementOnASingleLine == 4776 R.AllowShortCompoundRequirementOnASingleLine && 4777 AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine && 4778 AllowShortFunctionsOnASingleLine == 4779 R.AllowShortFunctionsOnASingleLine && 4780 AllowShortIfStatementsOnASingleLine == 4781 R.AllowShortIfStatementsOnASingleLine && 4782 AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine && 4783 AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine && 4784 AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType && 4785 AlwaysBreakBeforeMultilineStrings == 4786 R.AlwaysBreakBeforeMultilineStrings && 4787 AlwaysBreakTemplateDeclarations == 4788 R.AlwaysBreakTemplateDeclarations && 4789 AttributeMacros == R.AttributeMacros && 4790 BinPackArguments == R.BinPackArguments && 4791 BinPackParameters == R.BinPackParameters && 4792 BitFieldColonSpacing == R.BitFieldColonSpacing && 4793 BracedInitializerIndentWidth == R.BracedInitializerIndentWidth && 4794 BreakAdjacentStringLiterals == R.BreakAdjacentStringLiterals && 4795 BreakAfterAttributes == R.BreakAfterAttributes && 4796 BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations && 4797 BreakArrays == R.BreakArrays && 4798 BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators && 4799 BreakBeforeBraces == R.BreakBeforeBraces && 4800 BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations && 4801 BreakBeforeInlineASMColon == R.BreakBeforeInlineASMColon && 4802 BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators && 4803 BreakConstructorInitializers == R.BreakConstructorInitializers && 4804 BreakInheritanceList == R.BreakInheritanceList && 4805 BreakStringLiterals == R.BreakStringLiterals && 4806 ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas && 4807 CompactNamespaces == R.CompactNamespaces && 4808 ConstructorInitializerIndentWidth == 4809 R.ConstructorInitializerIndentWidth && 4810 ContinuationIndentWidth == R.ContinuationIndentWidth && 4811 Cpp11BracedListStyle == R.Cpp11BracedListStyle && 4812 DerivePointerAlignment == R.DerivePointerAlignment && 4813 DisableFormat == R.DisableFormat && 4814 EmptyLineAfterAccessModifier == R.EmptyLineAfterAccessModifier && 4815 EmptyLineBeforeAccessModifier == R.EmptyLineBeforeAccessModifier && 4816 ExperimentalAutoDetectBinPacking == 4817 R.ExperimentalAutoDetectBinPacking && 4818 FixNamespaceComments == R.FixNamespaceComments && 4819 ForEachMacros == R.ForEachMacros && 4820 IncludeStyle.IncludeBlocks == R.IncludeStyle.IncludeBlocks && 4821 IncludeStyle.IncludeCategories == R.IncludeStyle.IncludeCategories && 4822 IncludeStyle.IncludeIsMainRegex == 4823 R.IncludeStyle.IncludeIsMainRegex && 4824 IncludeStyle.IncludeIsMainSourceRegex == 4825 R.IncludeStyle.IncludeIsMainSourceRegex && 4826 IndentAccessModifiers == R.IndentAccessModifiers && 4827 IndentCaseBlocks == R.IndentCaseBlocks && 4828 IndentCaseLabels == R.IndentCaseLabels && 4829 IndentExternBlock == R.IndentExternBlock && 4830 IndentGotoLabels == R.IndentGotoLabels && 4831 IndentPPDirectives == R.IndentPPDirectives && 4832 IndentRequiresClause == R.IndentRequiresClause && 4833 IndentWidth == R.IndentWidth && 4834 IndentWrappedFunctionNames == R.IndentWrappedFunctionNames && 4835 InsertBraces == R.InsertBraces && 4836 InsertNewlineAtEOF == R.InsertNewlineAtEOF && 4837 IntegerLiteralSeparator == R.IntegerLiteralSeparator && 4838 JavaImportGroups == R.JavaImportGroups && 4839 JavaScriptQuotes == R.JavaScriptQuotes && 4840 JavaScriptWrapImports == R.JavaScriptWrapImports && 4841 KeepEmptyLinesAtEOF == R.KeepEmptyLinesAtEOF && 4842 KeepEmptyLinesAtTheStartOfBlocks == 4843 R.KeepEmptyLinesAtTheStartOfBlocks && 4844 Language == R.Language && 4845 LambdaBodyIndentation == R.LambdaBodyIndentation && 4846 LineEnding == R.LineEnding && MacroBlockBegin == R.MacroBlockBegin && 4847 MacroBlockEnd == R.MacroBlockEnd && Macros == R.Macros && 4848 MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep && 4849 NamespaceIndentation == R.NamespaceIndentation && 4850 NamespaceMacros == R.NamespaceMacros && 4851 ObjCBinPackProtocolList == R.ObjCBinPackProtocolList && 4852 ObjCBlockIndentWidth == R.ObjCBlockIndentWidth && 4853 ObjCBreakBeforeNestedBlockParam == 4854 R.ObjCBreakBeforeNestedBlockParam && 4855 ObjCPropertyAttributeOrder == R.ObjCPropertyAttributeOrder && 4856 ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty && 4857 ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList && 4858 PackConstructorInitializers == R.PackConstructorInitializers && 4859 PenaltyBreakAssignment == R.PenaltyBreakAssignment && 4860 PenaltyBreakBeforeFirstCallParameter == 4861 R.PenaltyBreakBeforeFirstCallParameter && 4862 PenaltyBreakComment == R.PenaltyBreakComment && 4863 PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess && 4864 PenaltyBreakOpenParenthesis == R.PenaltyBreakOpenParenthesis && 4865 PenaltyBreakScopeResolution == R.PenaltyBreakScopeResolution && 4866 PenaltyBreakString == R.PenaltyBreakString && 4867 PenaltyBreakTemplateDeclaration == 4868 R.PenaltyBreakTemplateDeclaration && 4869 PenaltyExcessCharacter == R.PenaltyExcessCharacter && 4870 PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine && 4871 PointerAlignment == R.PointerAlignment && 4872 QualifierAlignment == R.QualifierAlignment && 4873 QualifierOrder == R.QualifierOrder && 4874 RawStringFormats == R.RawStringFormats && 4875 ReferenceAlignment == R.ReferenceAlignment && 4876 RemoveBracesLLVM == R.RemoveBracesLLVM && 4877 RemoveParentheses == R.RemoveParentheses && 4878 RemoveSemicolon == R.RemoveSemicolon && 4879 RequiresClausePosition == R.RequiresClausePosition && 4880 RequiresExpressionIndentation == R.RequiresExpressionIndentation && 4881 SeparateDefinitionBlocks == R.SeparateDefinitionBlocks && 4882 ShortNamespaceLines == R.ShortNamespaceLines && 4883 SkipMacroDefinitionBody == R.SkipMacroDefinitionBody && 4884 SortIncludes == R.SortIncludes && 4885 SortJavaStaticImport == R.SortJavaStaticImport && 4886 SpaceAfterCStyleCast == R.SpaceAfterCStyleCast && 4887 SpaceAfterLogicalNot == R.SpaceAfterLogicalNot && 4888 SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword && 4889 SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators && 4890 SpaceBeforeCaseColon == R.SpaceBeforeCaseColon && 4891 SpaceBeforeCpp11BracedList == R.SpaceBeforeCpp11BracedList && 4892 SpaceBeforeCtorInitializerColon == 4893 R.SpaceBeforeCtorInitializerColon && 4894 SpaceBeforeInheritanceColon == R.SpaceBeforeInheritanceColon && 4895 SpaceBeforeJsonColon == R.SpaceBeforeJsonColon && 4896 SpaceBeforeParens == R.SpaceBeforeParens && 4897 SpaceBeforeParensOptions == R.SpaceBeforeParensOptions && 4898 SpaceAroundPointerQualifiers == R.SpaceAroundPointerQualifiers && 4899 SpaceBeforeRangeBasedForLoopColon == 4900 R.SpaceBeforeRangeBasedForLoopColon && 4901 SpaceBeforeSquareBrackets == R.SpaceBeforeSquareBrackets && 4902 SpaceInEmptyBlock == R.SpaceInEmptyBlock && 4903 SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments && 4904 SpacesInAngles == R.SpacesInAngles && 4905 SpacesInContainerLiterals == R.SpacesInContainerLiterals && 4906 SpacesInLineCommentPrefix.Minimum == 4907 R.SpacesInLineCommentPrefix.Minimum && 4908 SpacesInLineCommentPrefix.Maximum == 4909 R.SpacesInLineCommentPrefix.Maximum && 4910 SpacesInParens == R.SpacesInParens && 4911 SpacesInParensOptions == R.SpacesInParensOptions && 4912 SpacesInSquareBrackets == R.SpacesInSquareBrackets && 4913 Standard == R.Standard && 4914 StatementAttributeLikeMacros == R.StatementAttributeLikeMacros && 4915 StatementMacros == R.StatementMacros && TabWidth == R.TabWidth && 4916 TypeNames == R.TypeNames && TypenameMacros == R.TypenameMacros && 4917 UseTab == R.UseTab && 4918 VerilogBreakBetweenInstancePorts == 4919 R.VerilogBreakBetweenInstancePorts && 4920 WhitespaceSensitiveMacros == R.WhitespaceSensitiveMacros; 4921 } 4922 4923 std::optional<FormatStyle> GetLanguageStyle(LanguageKind Language) const; 4924 4925 // Stores per-language styles. A FormatStyle instance inside has an empty 4926 // StyleSet. A FormatStyle instance returned by the Get method has its 4927 // StyleSet set to a copy of the originating StyleSet, effectively keeping the 4928 // internal representation of that StyleSet alive. 4929 // 4930 // The memory management and ownership reminds of a birds nest: chicks 4931 // leaving the nest take photos of the nest with them. 4932 struct FormatStyleSet { 4933 typedef std::map<FormatStyle::LanguageKind, FormatStyle> MapType; 4934 4935 std::optional<FormatStyle> Get(FormatStyle::LanguageKind Language) const; 4936 4937 // Adds \p Style to this FormatStyleSet. Style must not have an associated 4938 // FormatStyleSet. 4939 // Style.Language should be different than LK_None. If this FormatStyleSet 4940 // already contains an entry for Style.Language, that gets replaced with the 4941 // passed Style. 4942 void Add(FormatStyle Style); 4943 4944 // Clears this FormatStyleSet. 4945 void Clear(); 4946 4947 private: 4948 std::shared_ptr<MapType> Styles; 4949 }; 4950 4951 static FormatStyleSet BuildStyleSetFromConfiguration( 4952 const FormatStyle &MainStyle, 4953 const std::vector<FormatStyle> &ConfigurationStyles); 4954 4955private: 4956 FormatStyleSet StyleSet; 4957 4958 friend std::error_code 4959 parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style, 4960 bool AllowUnknownOptions, 4961 llvm::SourceMgr::DiagHandlerTy DiagHandler, 4962 void *DiagHandlerCtxt); 4963}; 4964 4965/// Returns a format style complying with the LLVM coding standards: 4966/// http://llvm.org/docs/CodingStandards.html. 4967FormatStyle getLLVMStyle( 4968 FormatStyle::LanguageKind Language = FormatStyle::LanguageKind::LK_Cpp); 4969 4970/// Returns a format style complying with one of Google's style guides: 4971/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml. 4972/// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml. 4973/// https://developers.google.com/protocol-buffers/docs/style. 4974FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language); 4975 4976/// Returns a format style complying with Chromium's style guide: 4977/// http://www.chromium.org/developers/coding-style. 4978FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language); 4979 4980/// Returns a format style complying with Mozilla's style guide: 4981/// https://firefox-source-docs.mozilla.org/code-quality/coding-style/index.html. 4982FormatStyle getMozillaStyle(); 4983 4984/// Returns a format style complying with Webkit's style guide: 4985/// http://www.webkit.org/coding/coding-style.html 4986FormatStyle getWebKitStyle(); 4987 4988/// Returns a format style complying with GNU Coding Standards: 4989/// http://www.gnu.org/prep/standards/standards.html 4990FormatStyle getGNUStyle(); 4991 4992/// Returns a format style complying with Microsoft style guide: 4993/// https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017 4994FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language); 4995 4996FormatStyle getClangFormatStyle(); 4997 4998/// Returns style indicating formatting should be not applied at all. 4999FormatStyle getNoStyle(); 5000 5001/// Gets a predefined style for the specified language by name. 5002/// 5003/// Currently supported names: LLVM, Google, Chromium, Mozilla. Names are 5004/// compared case-insensitively. 5005/// 5006/// Returns ``true`` if the Style has been set. 5007bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language, 5008 FormatStyle *Style); 5009 5010/// Parse configuration from YAML-formatted text. 5011/// 5012/// Style->Language is used to get the base style, if the ``BasedOnStyle`` 5013/// option is present. 5014/// 5015/// The FormatStyleSet of Style is reset. 5016/// 5017/// When ``BasedOnStyle`` is not present, options not present in the YAML 5018/// document, are retained in \p Style. 5019/// 5020/// If AllowUnknownOptions is true, no errors are emitted if unknown 5021/// format options are occurred. 5022/// 5023/// If set all diagnostics are emitted through the DiagHandler. 5024std::error_code 5025parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style, 5026 bool AllowUnknownOptions = false, 5027 llvm::SourceMgr::DiagHandlerTy DiagHandler = nullptr, 5028 void *DiagHandlerCtx = nullptr); 5029 5030/// Like above but accepts an unnamed buffer. 5031inline std::error_code parseConfiguration(StringRef Config, FormatStyle *Style, 5032 bool AllowUnknownOptions = false) { 5033 return parseConfiguration(llvm::MemoryBufferRef(Config, "YAML"), Style, 5034 AllowUnknownOptions); 5035} 5036 5037/// Gets configuration in a YAML string. 5038std::string configurationAsText(const FormatStyle &Style); 5039 5040/// Returns the replacements necessary to sort all ``#include`` blocks 5041/// that are affected by ``Ranges``. 5042tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code, 5043 ArrayRef<tooling::Range> Ranges, 5044 StringRef FileName, 5045 unsigned *Cursor = nullptr); 5046 5047/// Returns the replacements corresponding to applying and formatting 5048/// \p Replaces on success; otheriwse, return an llvm::Error carrying 5049/// llvm::StringError. 5050llvm::Expected<tooling::Replacements> 5051formatReplacements(StringRef Code, const tooling::Replacements &Replaces, 5052 const FormatStyle &Style); 5053 5054/// Returns the replacements corresponding to applying \p Replaces and 5055/// cleaning up the code after that on success; otherwise, return an llvm::Error 5056/// carrying llvm::StringError. 5057/// This also supports inserting/deleting C++ #include directives: 5058/// - If a replacement has offset UINT_MAX, length 0, and a replacement text 5059/// that is an #include directive, this will insert the #include into the 5060/// correct block in the \p Code. 5061/// - If a replacement has offset UINT_MAX, length 1, and a replacement text 5062/// that is the name of the header to be removed, the header will be removed 5063/// from \p Code if it exists. 5064/// The include manipulation is done via ``tooling::HeaderInclude``, see its 5065/// documentation for more details on how include insertion points are found and 5066/// what edits are produced. 5067llvm::Expected<tooling::Replacements> 5068cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces, 5069 const FormatStyle &Style); 5070 5071/// Represents the status of a formatting attempt. 5072struct FormattingAttemptStatus { 5073 /// A value of ``false`` means that any of the affected ranges were not 5074 /// formatted due to a non-recoverable syntax error. 5075 bool FormatComplete = true; 5076 5077 /// If ``FormatComplete`` is false, ``Line`` records a one-based 5078 /// original line number at which a syntax error might have occurred. This is 5079 /// based on a best-effort analysis and could be imprecise. 5080 unsigned Line = 0; 5081}; 5082 5083/// Reformats the given \p Ranges in \p Code. 5084/// 5085/// Each range is extended on either end to its next bigger logic unit, i.e. 5086/// everything that might influence its formatting or might be influenced by its 5087/// formatting. 5088/// 5089/// Returns the ``Replacements`` necessary to make all \p Ranges comply with 5090/// \p Style. 5091/// 5092/// If ``Status`` is non-null, its value will be populated with the status of 5093/// this formatting attempt. See \c FormattingAttemptStatus. 5094tooling::Replacements reformat(const FormatStyle &Style, StringRef Code, 5095 ArrayRef<tooling::Range> Ranges, 5096 StringRef FileName = "<stdin>", 5097 FormattingAttemptStatus *Status = nullptr); 5098 5099/// Same as above, except if ``IncompleteFormat`` is non-null, its value 5100/// will be set to true if any of the affected ranges were not formatted due to 5101/// a non-recoverable syntax error. 5102tooling::Replacements reformat(const FormatStyle &Style, StringRef Code, 5103 ArrayRef<tooling::Range> Ranges, 5104 StringRef FileName, bool *IncompleteFormat); 5105 5106/// Clean up any erroneous/redundant code in the given \p Ranges in \p 5107/// Code. 5108/// 5109/// Returns the ``Replacements`` that clean up all \p Ranges in \p Code. 5110tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, 5111 ArrayRef<tooling::Range> Ranges, 5112 StringRef FileName = "<stdin>"); 5113 5114/// Fix namespace end comments in the given \p Ranges in \p Code. 5115/// 5116/// Returns the ``Replacements`` that fix the namespace comments in all 5117/// \p Ranges in \p Code. 5118tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style, 5119 StringRef Code, 5120 ArrayRef<tooling::Range> Ranges, 5121 StringRef FileName = "<stdin>"); 5122 5123/// Inserts or removes empty lines separating definition blocks including 5124/// classes, structs, functions, namespaces, and enums in the given \p Ranges in 5125/// \p Code. 5126/// 5127/// Returns the ``Replacements`` that inserts or removes empty lines separating 5128/// definition blocks in all \p Ranges in \p Code. 5129tooling::Replacements separateDefinitionBlocks(const FormatStyle &Style, 5130 StringRef Code, 5131 ArrayRef<tooling::Range> Ranges, 5132 StringRef FileName = "<stdin>"); 5133 5134/// Sort consecutive using declarations in the given \p Ranges in 5135/// \p Code. 5136/// 5137/// Returns the ``Replacements`` that sort the using declarations in all 5138/// \p Ranges in \p Code. 5139tooling::Replacements sortUsingDeclarations(const FormatStyle &Style, 5140 StringRef Code, 5141 ArrayRef<tooling::Range> Ranges, 5142 StringRef FileName = "<stdin>"); 5143 5144/// Returns the ``LangOpts`` that the formatter expects you to set. 5145/// 5146/// \param Style determines specific settings for lexing mode. 5147LangOptions getFormattingLangOpts(const FormatStyle &Style = getLLVMStyle()); 5148 5149/// Description to be used for help text for a ``llvm::cl`` option for 5150/// specifying format style. The description is closely related to the operation 5151/// of ``getStyle()``. 5152extern const char *StyleOptionHelpDescription; 5153 5154/// The suggested format style to use by default. This allows tools using 5155/// ``getStyle`` to have a consistent default style. 5156/// Different builds can modify the value to the preferred styles. 5157extern const char *DefaultFormatStyle; 5158 5159/// The suggested predefined style to use as the fallback style in ``getStyle``. 5160/// Different builds can modify the value to the preferred styles. 5161extern const char *DefaultFallbackStyle; 5162 5163/// Construct a FormatStyle based on ``StyleName``. 5164/// 5165/// ``StyleName`` can take several forms: 5166/// * "{<key>: <value>, ...}" - Set specic style parameters. 5167/// * "<style name>" - One of the style names supported by 5168/// getPredefinedStyle(). 5169/// * "file" - Load style configuration from a file called ``.clang-format`` 5170/// located in one of the parent directories of ``FileName`` or the current 5171/// directory if ``FileName`` is empty. 5172/// * "file:<format_file_path>" to explicitly specify the configuration file to 5173/// use. 5174/// 5175/// \param[in] StyleName Style name to interpret according to the description 5176/// above. 5177/// \param[in] FileName Path to start search for .clang-format if ``StyleName`` 5178/// == "file". 5179/// \param[in] FallbackStyle The name of a predefined style used to fallback to 5180/// in case \p StyleName is "file" and no file can be found. 5181/// \param[in] Code The actual code to be formatted. Used to determine the 5182/// language if the filename isn't sufficient. 5183/// \param[in] FS The underlying file system, in which the file resides. By 5184/// default, the file system is the real file system. 5185/// \param[in] AllowUnknownOptions If true, unknown format options only 5186/// emit a warning. If false, errors are emitted on unknown format 5187/// options. 5188/// 5189/// \returns FormatStyle as specified by ``StyleName``. If ``StyleName`` is 5190/// "file" and no file is found, returns ``FallbackStyle``. If no style could be 5191/// determined, returns an Error. 5192llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName, 5193 StringRef FallbackStyle, 5194 StringRef Code = "", 5195 llvm::vfs::FileSystem *FS = nullptr, 5196 bool AllowUnknownOptions = false); 5197 5198// Guesses the language from the ``FileName`` and ``Code`` to be formatted. 5199// Defaults to FormatStyle::LK_Cpp. 5200FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code); 5201 5202// Returns a string representation of ``Language``. 5203inline StringRef getLanguageName(FormatStyle::LanguageKind Language) { 5204 switch (Language) { 5205 case FormatStyle::LK_Cpp: 5206 return "C++"; 5207 case FormatStyle::LK_CSharp: 5208 return "CSharp"; 5209 case FormatStyle::LK_ObjC: 5210 return "Objective-C"; 5211 case FormatStyle::LK_Java: 5212 return "Java"; 5213 case FormatStyle::LK_JavaScript: 5214 return "JavaScript"; 5215 case FormatStyle::LK_Json: 5216 return "Json"; 5217 case FormatStyle::LK_Proto: 5218 return "Proto"; 5219 case FormatStyle::LK_TableGen: 5220 return "TableGen"; 5221 case FormatStyle::LK_TextProto: 5222 return "TextProto"; 5223 case FormatStyle::LK_Verilog: 5224 return "Verilog"; 5225 default: 5226 return "Unknown"; 5227 } 5228} 5229 5230bool isClangFormatOn(StringRef Comment); 5231bool isClangFormatOff(StringRef Comment); 5232 5233} // end namespace format 5234} // end namespace clang 5235 5236namespace std { 5237template <> 5238struct is_error_code_enum<clang::format::ParseError> : std::true_type {}; 5239} // namespace std 5240 5241#endif // LLVM_CLANG_FORMAT_FORMAT_H 5242