2022-07-11 14:21:38 +00:00
|
|
|
|
---
|
|
|
|
|
IndentWidth: 4
|
|
|
|
|
TabWidth: 4
|
|
|
|
|
---
|
|
|
|
|
Language: Cpp
|
|
|
|
|
|
|
|
|
|
# Align parameters on the open bracket, e.g.:
|
|
|
|
|
# someLongFunction(argument1,
|
|
|
|
|
# argument2);
|
|
|
|
|
AlignAfterOpenBracket: Align
|
|
|
|
|
|
|
|
|
|
# Align array column and left justify the columns e.g.:
|
|
|
|
|
# struct test demo[] =
|
|
|
|
|
# {
|
|
|
|
|
# {56, 23, "hello"},
|
|
|
|
|
# {-1, 93463, "world"},
|
|
|
|
|
# {7, 5, "!!" }
|
|
|
|
|
# };
|
|
|
|
|
AlignArrayOfStructures: Left
|
|
|
|
|
|
|
|
|
|
# Align assignments on consecutive lines. This will result in formattings like:
|
|
|
|
|
#
|
|
|
|
|
# int a = 1;
|
|
|
|
|
# int somelongname = 2;
|
|
|
|
|
# double c = 3;
|
|
|
|
|
#
|
|
|
|
|
# int d = 3;
|
|
|
|
|
# /* A comment. */
|
|
|
|
|
# double e = 4;
|
|
|
|
|
AlignConsecutiveAssignments: Consecutive
|
|
|
|
|
AlignConsecutiveBitFields: Consecutive
|
|
|
|
|
AlignConsecutiveDeclarations: Consecutive
|
|
|
|
|
AlignConsecutiveMacros: Consecutive
|
|
|
|
|
|
|
|
|
|
# Align escaped newlines as far left as possible.
|
|
|
|
|
# #define A \
|
|
|
|
|
# int aaaa; \
|
|
|
|
|
# int b; \
|
|
|
|
|
# int dddddddddd;
|
|
|
|
|
AlignEscapedNewlines: Left
|
|
|
|
|
|
|
|
|
|
# Horizontally align operands of binary and ternary expressions.
|
|
|
|
|
# Specifically, this aligns operands of a single expression that needs to be
|
|
|
|
|
# split over multiple lines, e.g.:
|
|
|
|
|
#
|
|
|
|
|
# int aaa = bbbbbbbbbbbbbbb +
|
|
|
|
|
# ccccccccccccccc;
|
|
|
|
|
AlignOperands: Align
|
|
|
|
|
|
|
|
|
|
# true: false:
|
|
|
|
|
# int a; // My comment a vs. int a; // My comment a
|
|
|
|
|
# int b = 2; // comment b int b = 2; // comment about b
|
|
|
|
|
AlignTrailingComments: true
|
|
|
|
|
|
|
|
|
|
# If the function declaration doesn’t fit on a line, allow putting all
|
|
|
|
|
# parameters of a function declaration onto the next line even if
|
|
|
|
|
# BinPackParameters is false.
|
|
|
|
|
#
|
|
|
|
|
# true:
|
|
|
|
|
# void myFunction(
|
|
|
|
|
# int a, int b, int c, int d, int e);
|
|
|
|
|
#
|
|
|
|
|
# false:
|
|
|
|
|
# void myFunction(int a,
|
|
|
|
|
# int b,
|
|
|
|
|
# int c,
|
|
|
|
|
# int d,
|
|
|
|
|
# int e);
|
|
|
|
|
AllowAllParametersOfDeclarationOnNextLine: false
|
|
|
|
|
AllowShortBlocksOnASingleLine: Never # "while (true) { continue; }" can be put on a single line.
|
|
|
|
|
|
|
|
|
|
# If true, short case labels will be contracted to a single line.
|
|
|
|
|
#
|
|
|
|
|
# true: false:
|
|
|
|
|
# switch (a) { vs. switch (a) {
|
|
|
|
|
# case 1: x = 1; break; case 1:
|
|
|
|
|
# case 2: return; x = 1;
|
|
|
|
|
# } break;
|
|
|
|
|
# case 2:
|
|
|
|
|
# return;
|
|
|
|
|
# }
|
|
|
|
|
AllowShortCaseLabelsOnASingleLine: true
|
|
|
|
|
AllowShortEnumsOnASingleLine: true # enum { A, B } myEnum;
|
|
|
|
|
|
|
|
|
|
# Only merge functions defined inside a class. Implies “empty”.
|
|
|
|
|
#
|
|
|
|
|
# class Foo {
|
|
|
|
|
# void f() { foo(); }
|
|
|
|
|
# };
|
|
|
|
|
# void f() {
|
|
|
|
|
# foo();
|
|
|
|
|
# }
|
|
|
|
|
# void f() {}
|
|
|
|
|
AllowShortFunctionsOnASingleLine: Inline
|
|
|
|
|
AllowShortIfStatementsOnASingleLine: false
|
|
|
|
|
|
|
|
|
|
# Only merge empty lambdas.
|
|
|
|
|
#
|
|
|
|
|
# auto lambda = [](int a) {}
|
|
|
|
|
# auto lambda2 = [](int a) {
|
|
|
|
|
# return a;
|
|
|
|
|
# };
|
|
|
|
|
AllowShortLambdasOnASingleLine: Empty
|
|
|
|
|
AllowShortLoopsOnASingleLine: false
|
|
|
|
|
|
|
|
|
|
# true: false:
|
|
|
|
|
# aaaa = vs. aaaa = "bbbb"
|
|
|
|
|
# "bbbb" "cccc";
|
|
|
|
|
# "cccc";
|
|
|
|
|
AlwaysBreakBeforeMultilineStrings: true
|
|
|
|
|
|
|
|
|
|
# Force break after template declaration only when the following declaration
|
|
|
|
|
# spans multiple lines.
|
|
|
|
|
#
|
|
|
|
|
# template <typename T> T foo() {
|
|
|
|
|
# }
|
|
|
|
|
# template <typename T>
|
|
|
|
|
# T foo(int aaaaaaaaaaaaaaaaaaaaa,
|
|
|
|
|
# int bbbbbbbbbbbbbbbbbbbbb) {
|
|
|
|
|
# }
|
|
|
|
|
AlwaysBreakTemplateDeclarations: MultiLine
|
|
|
|
|
|
|
|
|
|
# If false, a function call’s arguments will either be all on the same line or
|
|
|
|
|
# will have one line each.
|
|
|
|
|
#
|
|
|
|
|
# true:
|
|
|
|
|
# void f() {
|
|
|
|
|
# f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
|
|
|
|
|
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
|
|
|
|
|
# }
|
|
|
|
|
#
|
|
|
|
|
# false:
|
|
|
|
|
# void f() {
|
|
|
|
|
# f(aaaaaaaaaaaaaaaaaaaa,
|
|
|
|
|
# aaaaaaaaaaaaaaaaaaaa,
|
|
|
|
|
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
|
|
|
|
|
# }
|
|
|
|
|
BinPackArguments: false
|
|
|
|
|
BinPackParameters: false # As BinPackArguments but for function definition parameters
|
|
|
|
|
|
|
|
|
|
# Add space after the : only (space may be added before if needed for
|
|
|
|
|
# AlignConsecutiveBitFields).
|
|
|
|
|
#
|
|
|
|
|
# unsigned bf: 2;
|
|
|
|
|
BitFieldColonSpacing: After
|
|
|
|
|
|
|
|
|
|
# LooooooooooongType loooooooooooooooooooooongVariable =
|
|
|
|
|
# someLooooooooooooooooongFunction();
|
|
|
|
|
#
|
|
|
|
|
# bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
|
|
|
|
|
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
|
|
|
|
|
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
|
|
|
|
|
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
|
|
|
|
|
# ccccccccccccccccccccccccccccccccccccccccc;
|
|
|
|
|
BreakBeforeBinaryOperators: None
|
|
|
|
|
|
|
|
|
|
# Always attach braces to surrounding context, but break before braces on
|
|
|
|
|
# function, namespace and class definitions.
|
|
|
|
|
BreakBeforeBraces: Linux
|
|
|
|
|
|
|
|
|
|
# true:
|
|
|
|
|
# template<typename T>
|
|
|
|
|
# concept ...
|
|
|
|
|
#
|
|
|
|
|
# false:
|
|
|
|
|
# template<typename T> concept ...
|
|
|
|
|
BreakBeforeConceptDeclarations: false
|
|
|
|
|
|
|
|
|
|
# true:
|
|
|
|
|
# veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
|
|
|
|
|
# ? firstValue
|
|
|
|
|
# : SecondValueVeryVeryVeryVeryLong;
|
|
|
|
|
#
|
|
|
|
|
# false:
|
|
|
|
|
# veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
|
|
|
|
|
# firstValue :
|
|
|
|
|
# SecondValueVeryVeryVeryVeryLong;
|
|
|
|
|
BreakBeforeTernaryOperators: true
|
|
|
|
|
|
|
|
|
|
# Break constructor initializers before the colon and commas, and align the
|
|
|
|
|
# commas with the colon.
|
|
|
|
|
#
|
|
|
|
|
# Constructor()
|
|
|
|
|
# : initializer1()
|
|
|
|
|
# , initializer2()
|
|
|
|
|
BreakConstructorInitializers: BeforeComma
|
|
|
|
|
|
|
|
|
|
# Break inheritance list only after the commas.
|
|
|
|
|
#
|
|
|
|
|
# class Foo : Base1,
|
|
|
|
|
# Base2
|
|
|
|
|
# {};
|
|
|
|
|
BreakInheritanceList: AfterComma
|
|
|
|
|
|
|
|
|
|
# true:
|
|
|
|
|
# const char* x = "veryVeryVeryVeryVeryVe"
|
|
|
|
|
# "ryVeryVeryVeryVeryVery"
|
|
|
|
|
# "VeryLongString";
|
|
|
|
|
BreakStringLiterals: true
|
|
|
|
|
ColumnLimit: 100
|
|
|
|
|
|
|
|
|
|
# false:
|
|
|
|
|
# namespace Foo {
|
|
|
|
|
# namespace Bar {
|
|
|
|
|
# }
|
|
|
|
|
# }
|
|
|
|
|
CompactNamespaces: false
|
|
|
|
|
|
|
|
|
|
# true: false:
|
|
|
|
|
# vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 };
|
|
|
|
|
# vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} };
|
|
|
|
|
# f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]);
|
|
|
|
|
# new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 };
|
|
|
|
|
Cpp11BracedListStyle: true
|
|
|
|
|
|
|
|
|
|
# Analyze the formatted file for the most used line ending (\r\n or \n). UseCRLF
|
|
|
|
|
# is only used as a fallback if none can be derived.
|
|
|
|
|
DeriveLineEnding: true
|
|
|
|
|
DerivePointerAlignment: true # As per DeriveLineEnding except for pointers and references
|
|
|
|
|
|
|
|
|
|
# Add empty line only when access modifier starts a new logical block. Logical
|
|
|
|
|
# block is a group of one or more member fields or functions.
|
|
|
|
|
#
|
|
|
|
|
# struct foo {
|
|
|
|
|
# private:
|
|
|
|
|
# int i;
|
|
|
|
|
#
|
|
|
|
|
# protected:
|
|
|
|
|
# int j;
|
|
|
|
|
# /* comment */
|
|
|
|
|
# public:
|
|
|
|
|
# foo() {}
|
|
|
|
|
#
|
|
|
|
|
# private:
|
|
|
|
|
# protected:
|
|
|
|
|
# };
|
|
|
|
|
EmptyLineBeforeAccessModifier: LogicalBlock
|
|
|
|
|
|
|
|
|
|
# true: false:
|
|
|
|
|
# namespace a { vs. namespace a {
|
|
|
|
|
# foo(); foo();
|
|
|
|
|
# bar(); bar();
|
|
|
|
|
# } // namespace a }
|
|
|
|
|
FixNamespaceComments: true
|
|
|
|
|
|
|
|
|
|
# false: true:
|
|
|
|
|
# class C { vs. class C {
|
|
|
|
|
# class D { class D {
|
|
|
|
|
# void bar(); void bar();
|
|
|
|
|
# protected: protected:
|
|
|
|
|
# D(); D();
|
|
|
|
|
# }; };
|
|
|
|
|
# public: public:
|
|
|
|
|
# C(); C();
|
|
|
|
|
# }; };
|
|
|
|
|
# void foo() { void foo() {
|
|
|
|
|
# return 1; return 1;
|
|
|
|
|
# } }
|
|
|
|
|
IndentAccessModifiers: false
|
|
|
|
|
|
|
|
|
|
# false: true:
|
|
|
|
|
# switch (fool) { vs. switch (fool) {
|
|
|
|
|
# case 1: { case 1:
|
|
|
|
|
# bar(); {
|
|
|
|
|
# } break; bar();
|
|
|
|
|
# default: { }
|
|
|
|
|
# plop(); break;
|
|
|
|
|
# } default:
|
|
|
|
|
# } {
|
|
|
|
|
# plop();
|
|
|
|
|
# }
|
|
|
|
|
# }
|
|
|
|
|
IndentCaseBlocks: false
|
|
|
|
|
|
|
|
|
|
# false: true:
|
|
|
|
|
# switch (fool) { vs. switch (fool) {
|
|
|
|
|
# case 1: case 1:
|
|
|
|
|
# bar(); bar();
|
|
|
|
|
# break; break;
|
|
|
|
|
# default: default:
|
|
|
|
|
# plop(); plop();
|
|
|
|
|
# } }
|
|
|
|
|
IndentCaseLabels: true
|
|
|
|
|
|
|
|
|
|
# extern "C" {
|
|
|
|
|
# void foo();
|
|
|
|
|
# }
|
|
|
|
|
IndentExternBlock: NoIndent
|
|
|
|
|
|
|
|
|
|
# Indents directives before the hash.
|
|
|
|
|
#
|
|
|
|
|
# #if FOO
|
|
|
|
|
# #if BAR
|
|
|
|
|
# #include <foo>
|
|
|
|
|
# #endif
|
|
|
|
|
# #endif
|
|
|
|
|
IndentPPDirectives: BeforeHash
|
|
|
|
|
|
|
|
|
|
# true: false:
|
|
|
|
|
# if (foo) { vs. if (foo) {
|
|
|
|
|
# bar();
|
|
|
|
|
# bar(); }
|
|
|
|
|
# }
|
|
|
|
|
KeepEmptyLinesAtTheStartOfBlocks: false
|
|
|
|
|
|
|
|
|
|
# The maximum number of consecutive empty lines to keep.
|
|
|
|
|
#
|
|
|
|
|
# MaxEmptyLinesToKeep: 1 vs. MaxEmptyLinesToKeep: 0
|
|
|
|
|
# int f() { int f() {
|
|
|
|
|
# int = 1; int i = 1;
|
|
|
|
|
# i = foo();
|
|
|
|
|
# i = foo(); return i;
|
|
|
|
|
# }
|
|
|
|
|
# return i;
|
|
|
|
|
# }
|
|
|
|
|
MaxEmptyLinesToKeep: 1
|
|
|
|
|
NamespaceIndentation: None
|
|
|
|
|
|
|
|
|
|
# Put all constructor initializers on the current line if they fit. Otherwise,
|
|
|
|
|
# put each one on its own line.
|
|
|
|
|
#
|
|
|
|
|
# Constructor() : a(), b()
|
|
|
|
|
#
|
|
|
|
|
# Constructor()
|
|
|
|
|
# : aaaaaaaaaaaaaaaaaaaa(),
|
|
|
|
|
# bbbbbbbbbbbbbbbbbbbb(),
|
|
|
|
|
# ddddddddddddd()
|
|
|
|
|
PackConstructorInitializers: CurrentLine
|
|
|
|
|
PointerAlignment: Right
|
|
|
|
|
|
|
|
|
|
# false:
|
|
|
|
|
# // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
|
|
|
|
|
# /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
|
|
|
|
|
#
|
|
|
|
|
# true:
|
|
|
|
|
# // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
|
|
|
|
|
# // information
|
|
|
|
|
# /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
|
|
|
|
|
# * information */
|
|
|
|
|
ReflowComments: true
|
|
|
|
|
|
|
|
|
|
# false: true:
|
|
|
|
|
#
|
|
|
|
|
# if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D))
|
|
|
|
|
# handleFunctionDecl(D); handleFunctionDecl(D);
|
|
|
|
|
# } else if (isa<VarDecl>(D)) { else if (isa<VarDecl>(D))
|
|
|
|
|
# handleVarDecl(D); handleVarDecl(D);
|
|
|
|
|
# }
|
|
|
|
|
#
|
|
|
|
|
# if (isa<VarDecl>(D)) { vs. if (isa<VarDecl>(D)) {
|
|
|
|
|
# for (auto *A : D.attrs()) { for (auto *A : D.attrs())
|
|
|
|
|
# if (shouldProcessAttr(A)) { if (shouldProcessAttr(A))
|
|
|
|
|
# handleAttr(A); handleAttr(A);
|
|
|
|
|
# } }
|
|
|
|
|
# }
|
|
|
|
|
# }
|
|
|
|
|
#
|
|
|
|
|
# if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D))
|
|
|
|
|
# for (auto *A : D.attrs()) { for (auto *A : D.attrs())
|
|
|
|
|
# handleAttr(A); handleAttr(A);
|
|
|
|
|
# }
|
|
|
|
|
# }
|
|
|
|
|
#
|
|
|
|
|
# if (auto *D = (T)(D)) { vs. if (auto *D = (T)(D)) {
|
|
|
|
|
# if (shouldProcess(D)) { if (shouldProcess(D))
|
|
|
|
|
# handleVarDecl(D); handleVarDecl(D);
|
|
|
|
|
# } else { else
|
|
|
|
|
# markAsIgnored(D); markAsIgnored(D);
|
|
|
|
|
# } }
|
|
|
|
|
# }
|
|
|
|
|
#
|
|
|
|
|
# if (a) { vs. if (a)
|
|
|
|
|
# b(); b();
|
|
|
|
|
# } else { else if (c)
|
|
|
|
|
# if (c) { d();
|
|
|
|
|
# d(); else
|
|
|
|
|
# } else { e();
|
|
|
|
|
# e();
|
|
|
|
|
# }
|
|
|
|
|
# }
|
|
|
|
|
RemoveBracesLLVM: true
|
|
|
|
|
|
|
|
|
|
# Never v.s. Always
|
|
|
|
|
# #include <cstring> #include <cstring>
|
|
|
|
|
# struct Foo {
|
|
|
|
|
# int a, b, c; struct Foo {
|
|
|
|
|
# }; int a, b, c;
|
|
|
|
|
# namespace Ns { };
|
|
|
|
|
# class Bar {
|
|
|
|
|
# public: namespace Ns {
|
|
|
|
|
# struct Foobar { class Bar {
|
|
|
|
|
# int a; public:
|
|
|
|
|
# int b; struct Foobar {
|
|
|
|
|
# }; int a;
|
|
|
|
|
# private: int b;
|
|
|
|
|
# int t; };
|
|
|
|
|
# int method1() {
|
|
|
|
|
# // ... private:
|
|
|
|
|
# } int t;
|
|
|
|
|
# enum List {
|
|
|
|
|
# ITEM1, int method1() {
|
|
|
|
|
# ITEM2 // ...
|
|
|
|
|
# }; }
|
|
|
|
|
# template<typename T>
|
|
|
|
|
# int method2(T x) { enum List {
|
|
|
|
|
# // ... ITEM1,
|
|
|
|
|
# } ITEM2
|
|
|
|
|
# int i, j, k; };
|
|
|
|
|
# int method3(int par) {
|
|
|
|
|
# // ... template<typename T>
|
|
|
|
|
# } int method2(T x) {
|
|
|
|
|
# }; // ...
|
|
|
|
|
# class C {}; }
|
|
|
|
|
# }
|
|
|
|
|
# int i, j, k;
|
|
|
|
|
#
|
|
|
|
|
# int method3(int par) {
|
|
|
|
|
# // ...
|
|
|
|
|
# }
|
|
|
|
|
# };
|
|
|
|
|
#
|
|
|
|
|
# class C {};
|
|
|
|
|
# }
|
|
|
|
|
SeparateDefinitionBlocks: Always
|
|
|
|
|
|
|
|
|
|
# true: false:
|
|
|
|
|
# int a = 5; vs. int a= 5;
|
|
|
|
|
# a += 42; a+= 42;
|
|
|
|
|
SpaceBeforeAssignmentOperators: true
|
|
|
|
|
|
|
|
|
|
# Put a space before opening parentheses only after control statement keywords
|
|
|
|
|
# (for/if/while...).
|
|
|
|
|
#
|
|
|
|
|
# void f() {
|
|
|
|
|
# if (true) {
|
|
|
|
|
# f();
|
|
|
|
|
# }
|
|
|
|
|
# }
|
|
|
|
|
SpaceBeforeParens: ControlStatements
|
|
|
|
|
SpacesBeforeTrailingComments: 1
|
|
|
|
|
|
|
|
|
|
# static_cast<int>(arg);
|
|
|
|
|
# std::function<void(int)> fct;
|
|
|
|
|
SpacesInAngles: Never
|
|
|
|
|
|
|
|
|
|
Standard: Auto
|
|
|
|
|
|
|
|
|
|
# Macros which are ignored in front of a statement, as if they were an
|
|
|
|
|
# attribute. So that they are not parsed as identifier, for example for Qts
|
|
|
|
|
# emit.
|
|
|
|
|
# unsigned char data = 'x';
|
|
|
|
|
# emit signal(data); // This is parsed as variable declaration.
|
|
|
|
|
#
|
|
|
|
|
# vs.
|
|
|
|
|
#
|
|
|
|
|
# unsigned char data = 'x';
|
|
|
|
|
# emit signal(data); // Now it's fine again.
|
|
|
|
|
StatementAttributeLikeMacros: [emit]
|
|
|
|
|
---
|