This revision was automatically updated to reflect the committed changes.
Closed by commit rL306089: [clang-format] Update style documentation, NFC
(authored by krasimir).
Changed prior to commit:
https://reviews.llvm.org/D34457?vs=103399&id=103698#toc
Repository:
rL LLVM
https://reviews.llvm.org/D34457
Files:
cfe/trunk/docs/ClangFormatStyleOptions.rst
cfe/trunk/include/clang/Format/Format.h
Index: cfe/trunk/include/clang/Format/Format.h
===================================================================
--- cfe/trunk/include/clang/Format/Format.h
+++ cfe/trunk/include/clang/Format/Format.h
@@ -652,12 +652,12 @@
/// struct foo
/// {
/// int x;
- /// }
+ /// };
///
/// false:
/// struct foo {
/// int x;
- /// }
+ /// };
/// \endcode
bool AfterStruct;
/// \brief Wrap union definitions.
@@ -733,16 +733,15 @@
/// ? firstValue
/// : SecondValueVeryVeryVeryVeryLong;
///
- /// true:
+ /// false:
/// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
/// firstValue :
/// SecondValueVeryVeryVeryVeryLong;
/// \endcode
bool BreakBeforeTernaryOperators;
/// \brief Different ways to break initializers.
- enum BreakConstructorInitializersStyle
- {
+ enum BreakConstructorInitializersStyle {
/// Break constructor initializers before the colon and after the commas.
/// \code
/// Constructor()
@@ -767,7 +766,7 @@
BCIS_AfterColon
};
- /// \brief The constructor initializers style to use..
+ /// \brief The constructor initializers style to use.
BreakConstructorInitializersStyle BreakConstructorInitializers;
/// \brief Break after each annotation on a field in Java files.
Index: cfe/trunk/docs/ClangFormatStyleOptions.rst
===================================================================
--- cfe/trunk/docs/ClangFormatStyleOptions.rst
+++ cfe/trunk/docs/ClangFormatStyleOptions.rst
@@ -309,12 +309,28 @@
* ``SFS_None`` (in configuration: ``None``)
Never merge functions into a single line.
+ * ``SFS_InlineOnly`` (in configuration: ``InlineOnly``)
+ Only merge functions defined inside a class. Same as "inline",
+ except it does not implies "empty": i.e. top level empty functions
+ are not merged either.
+
+ .. code-block:: c++
+
+ class Foo {
+ void f() { foo(); }
+ };
+ void f() {
+ foo();
+ }
+ void f() {
+ }
+
* ``SFS_Empty`` (in configuration: ``Empty``)
Only merge empty functions.
.. code-block:: c++
- void f() { bar(); }
+ void f() {}
void f2() {
bar2();
}
@@ -327,6 +343,10 @@
class Foo {
void f() { foo(); }
};
+ void f() {
+ foo();
+ }
+ void f() {}
* ``SFS_All`` (in configuration: ``All``)
Merge all functions fitting on a single line.
@@ -521,11 +541,11 @@
.. code-block:: c++
true:
- class foo
- {};
+ class foo {};
false:
- class foo {};
+ class foo
+ {};
* ``bool AfterControlStatement`` Wrap control statements (``if``/``for``/``while``/``switch``/..).
@@ -659,6 +679,18 @@
* ``bool IndentBraces`` Indent the wrapped braces themselves.
+ * ``bool SplitEmptyFunctionBody`` If ``false``, empty function body can be put on a single line.
+ This option is used only if the opening brace of the function has
+ already been wrapped, i.e. the `AfterFunction` brace wrapping mode is
+ set, and the function could/should not be put on a single line (as per
+ `AllowShortFunctionsOnASingleLine` and constructor formatting options).
+
+ .. code-block:: c++
+
+ int f() vs. inf f()
+ {} {
+ }
+
**BreakAfterJavaFieldAnnotations** (``bool``)
Break after each annotation on a field in Java files.
@@ -899,17 +931,40 @@
firstValue :
SecondValueVeryVeryVeryVeryLong;
-**BreakConstructorInitializersBeforeComma** (``bool``)
- Always break constructor initializers before commas and align
- the commas with the colon.
+**BreakConstructorInitializers** (``BreakConstructorInitializersStyle``)
+ The constructor initializers style to use.
+
+ Possible values:
+
+ * ``BCIS_BeforeColon`` (in configuration: ``BeforeColon``)
+ Break constructor initializers before the colon and after the commas.
+
+ .. code-block:: c++
+
+ Constructor()
+ : initializer1(),
+ initializer2()
+
+ * ``BCIS_BeforeComma`` (in configuration: ``BeforeComma``)
+ Break constructor initializers before the colon and commas, and align
+ the commas with the colon.
+
+ .. code-block:: c++
+
+ Constructor()
+ : initializer1()
+ , initializer2()
+
+ * ``BCIS_AfterColon`` (in configuration: ``AfterColon``)
+ Break constructor initializers after the colon and commas.
+
+ .. code-block:: c++
+
+ Constructor() :
+ initializer1(),
+ initializer2()
- .. code-block:: c++
- true: false:
- SomeClass::Constructor() vs. SomeClass::Constructor() : a(a),
- : a(a) b(b),
- , b(b) c(c) {}
- , c(c) {}
**BreakStringLiterals** (``bool``)
Allow breaking string literals when formatting.
@@ -931,6 +986,31 @@
// Will leave the following line unaffected
#include <vector> // FOOBAR pragma: keep
+**CompactNamespaces** (``bool``)
+ If ``true``, consecutive namespace declarations will be on the same
+ line. If ``false``, each namespace is declared on a new line.
+
+ .. code-block:: c++
+
+ true:
+ namespace Foo { namespace Bar {
+ }}
+
+ false:
+ namespace Foo {
+ namespace Bar {
+ }
+ }
+
+ If it does not fit on a single line, the overflowing namespaces get
+ wrapped:
+
+ .. code-block:: c++
+
+ namespace Foo { namespace Bar {
+ namespace Extra {
+ }}}
+
**ConstructorInitializerAllOnOneLineOrOnePerLine** (``bool``)
If the constructor initializers don't fit on a line, put each
initializer on its own line.
@@ -1321,6 +1401,9 @@
Add a space in front of an Objective-C protocol list, i.e. use
``Foo <Protocol>`` instead of ``Foo<Protocol>``.
+**PenaltyBreakAssignment** (``unsigned``)
+ The penalty for breaking around an assignment operator.
+
**PenaltyBreakBeforeFirstCallParameter** (``unsigned``)
The penalty for breaking a function call after ``call(``.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
