This is an archive of the discontinued LLVM Phabricator instance.

Differential D57732

Correct inf typo
ClosedPublic

Authored by gaul on Feb 4 2019, 7:19 PM.

Download Raw Diff

Details

Reviewers

Commits

rG4daa8d1de6dd: Correct inf typo

Diff Detail

Repository: rG LLVM Github Monorepo

Event Timeline

gaul created this revision.Feb 4 2019, 7:19 PM

Herald added a project: Restricted Project. · View Herald TranscriptFeb 4 2019, 7:19 PM

Herald added a subscriber: cfe-commits. · View Herald Transcript

Harbormaster completed remote builds in B27720: Diff 185221.Feb 4 2019, 7:21 PM

gaul added a reviewer: krasimir.Feb 4 2019, 7:25 PM

Thank you!

This revision is now accepted and ready to land.Feb 5 2019, 2:21 AM

Do you need someone to commit this change for you?

In D57732#1781437, @Jim wrote:

Do you need someone to commit this change for you?

I assume so -- this is my first PR for clang and don't know what the procedure is.

I can commit it for you.
If you are interested in obtaining the commit right. you can refer https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access.

Closed by commit rG4daa8d1de6dd: Correct inf typo (authored by gaul, committed by Jim). · Explain WhyDec 12 2019, 7:01 PM

This revision was automatically updated to reflect the committed changes.

Revision Contents

Path

Size

clang/

docs/

ClangFormatStyleOptions.rst

2 lines

include/

clang/

Format/

2 lines

Diff 233729

clang/docs/ClangFormatStyleOptions.rst

	Show First 20 Lines • Show All 952 Lines • ▼ Show 20 Lines		BraceWrapping (``BraceWrappingFlags``)
	* ``bool SplitEmptyFunction`` If ``false``, empty function body can be put on a single line.			* ``bool SplitEmptyFunction`` 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			This option is used only if the opening brace of the function has
	already been wrapped, i.e. the `AfterFunction` brace wrapping mode is			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			set, and the function could/should not be put on a single line (as per
	`AllowShortFunctionsOnASingleLine` and constructor formatting options).			`AllowShortFunctionsOnASingleLine` and constructor formatting options).

	.. code-block:: c++			.. code-block:: c++

	int f() vs. inf f()			int f() vs. int f()
	{} {			{} {
	}			}

	* ``bool SplitEmptyRecord`` If ``false``, empty record (e.g. class, struct or union) body			* ``bool SplitEmptyRecord`` If ``false``, empty record (e.g. class, struct or union) body
	can be put on a single line. This option is used only if the opening			can be put on a single line. This option is used only if the opening
	brace of the record has already been wrapped, i.e. the `AfterClass`			brace of the record has already been wrapped, i.e. the `AfterClass`
	(for classes) brace wrapping mode is set.			(for classes) brace wrapping mode is set.

	▲ Show 20 Lines • Show All 1,594 Lines • Show Last 20 Lines

clang/include/clang/Format/Format.h

	Show First 20 Lines • Show All 975 Lines • ▼ Show 20 Lines		struct BraceWrappingFlags {
	/// Indent the wrapped braces themselves.			/// Indent the wrapped braces themselves.
	bool IndentBraces;			bool IndentBraces;
	/// If ``false``, empty function body can be put on a single line.			/// 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			/// This option is used only if the opening brace of the function has
	/// already been wrapped, i.e. the `AfterFunction` brace wrapping mode is			/// 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			/// set, and the function could/should not be put on a single line (as per
	/// `AllowShortFunctionsOnASingleLine` and constructor formatting options).			/// `AllowShortFunctionsOnASingleLine` and constructor formatting options).
	/// \code			/// \code
	/// int f() vs. inf f()			/// int f() vs. int f()
	/// {} {			/// {} {
	/// }			/// }
	/// \endcode			/// \endcode
	///			///
	bool SplitEmptyFunction;			bool SplitEmptyFunction;
	/// If ``false``, empty record (e.g. class, struct or union) body			/// If ``false``, empty record (e.g. class, struct or union) body
	/// can be put on a single line. This option is used only if the opening			/// can be put on a single line. This option is used only if the opening
	/// brace of the record has already been wrapped, i.e. the `AfterClass`			/// brace of the record has already been wrapped, i.e. the `AfterClass`
	▲ Show 20 Lines • Show All 1,458 Lines • Show Last 20 Lines