本软件适用于C, C++, C++/CLI, Objective‑C, C#, and Java
一、使用流程
1.安装软件
linux:apt install astyle,重启vscode
windows:下载最新版本,并将exe路径添加至PATH,重启vscode
2.安装vscode插件Astyle
3.配置
使用:设置->拓展->Astyle->在settings.json中编辑(后附具体配置)
配置示意图
"astyle.additional_languages": [
"c",
"cpp",
],
"astyle.cmd_options": [
"--style=allman",
"--indent=spaces=4",
"--indent-modifiers",
"--indent-switches",
"--indent-cases",
"--indent-namespaces",
"--indent-preproc-block",
"--min-conditional-indent=2",
"--pad-oper",
"--pad-header",
"--unpad-paren",
"--delete-empty-lines",
"--align-pointer=name",
"--align-reference=name",
"--keep-one-line-statements",
"--convert-tabs",
"--close-templates",
/*"--max-code-length=#", 单行code最大长度
"--break-after-logical",*/
"--suffix=none",
"--lineend=linux",
"--verbose",
],
"[c]": {
"editor.defaultFormatter": "chiehyu.vscode-astyle"
},
"[cpp]": {
"editor.defaultFormatter": "chiehyu.vscode-astyle"
},
(配置参考:RT-thread)
具体配置:
1.大括号选项
--style=allman / --style=bsd / --style=break / -A1 :分离大括号风格
int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}
--style=java / --style=attach / -A2 :JAVA风格 ——附加大括号
int Foo(bool isBar) {
if (isBar) {
bar();
return 1;
} else
return 0;
}
--style=kr / --style=k/r / -A3:Linux风格 —— 开始的大括号与名称空间、类和函数定义分开。其余大括号附加到函数内的所有其他内容,包括数组、结构体、枚举和语句。
int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
} else
return 0;
}
--style=stroustrup / -A4:Stroustrup风格 —— 使用了linux大括号,并将大括号的结束头与结束头分开(例如:break - closing - headers)。开始的大括号只从函数定义中断开。开始的大括号附加到函数中的所有其他内容,包括名称空间、类、数组、结构、枚举和语句。这种样式经常与“attach - closing - while”、tab缩进和5个空格缩进一起使用。
int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
}
else
return 0;
}
--style=whitesmith / -A5:白铁匠风格 —— 使用破碎的,缩进的括号。Switch块和类块缩进以防止以下case语句和c++类修饰符(public, private, protected)的“挂缩进”。
int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}
--style=ratliff / --style=banner / -A6:Ratliff风格 —— 使用附加的,缩进的括号。Switch块和类块缩进是为了防止下面的case语句和c++类修饰符(public, private, protected)出现“挂缩进”。
int Foo(bool isBar) {
if (isBar) {
bar();
return 1;
}
else
return 0;
}
--style=gnu / -A7:GNU风格 —— 使用断括号。额外的缩进只被添加到函数内的块中。整个块都是缩进的,而不仅仅是大括号。这种样式经常用于缩进2个空格。
int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}
--style=linux / --style=knf / -A8:Linux风格 —— 使用Linux大括号。开始的大括号与名称空间、类和函数定义分开。大括号附加到函数内的所有其他内容,包括数组、结构体、枚举和语句。最小的条件缩进是一半缩进。如果您想要不同的最小条件缩进,请使用K&R样式。这种风格最适合大缩进。它经常与缩进8个空格一起使用。也称为内核范式(KNF)风格,这是在Linux BSD内核中使用的风格。
int Foo(bool isBar)
{
if (isFoo) {
bar();
return 1;
} else
return 0;
}
--style=horstmann / --style=run-in / -A9:Horstmann风格 —— 使用破括号和插入语句。switch是缩进的,以允许在打开开关块上磨合。这种样式经常使用缩进3个空格。
int Foo(bool isBar)
{ if (isBar)
{ bar();
return 1;
}
else
return 0;
}
--style=1tbs / --style=otbs / -A10:One True Brace 风格 —— 使用linux大括号,并将大括号添加到未加大括号的条件语句中。开始的大括号与名称空间、类和函数定义分开。大括号附加到函数内的所有其他内容,包括数组、结构体、枚举和语句。
int Foo(bool isBar)
{
if (isFoo) {
bar();
return 1;
} else {
return 0;
}
}
--style=pico / -A11:Pico风格 —— 使用断开的大括号和带有附加的闭大括号的run-in语句。右大括号附加到代码块的最后一行。开关是缩进的,以允许在打开开关块上磨合。这种风格意味着保持一行块和保持一行语句。如果使用了add-大括号,它们将被添加为一行大括号。这种样式经常用于缩进2个空格。
int Foo(bool isBar)
{ if (isBar)
{ bar();
return 1; }
else
return 0; }
--style=lisp / --style=python / -A12:Lisp风格 —— 使用附加的开括号和闭括号。右大括号附加到代码块的最后一行。这种风格意味着保持一行语句,而不是保持一行块。此样式不支持单行大括号。如果使用了add-one-line-大括号,它们将被添加为多行大括号。
int Foo(bool isBar) {
if (isBar) {
bar()
return 1; }
else
return 0; }
--style=google / -A14: 谷歌风格 —— 使用附加的花括号和缩进的类访问修饰符。有关缩进修饰符格式的示例,请参阅缩进修饰符选项。这实际上不是唯一的大括号风格,而是带有非大括号变体的Java风格。这种样式经常用于缩进2个空格。
int Foo(bool isBar) {
if (isBar) {
bar();
return 1;
} else
return 0;
}
--style=vtk / -A15:VTK(可视化工具包)风格 —— 使用破碎、缩进的大括号,除了类、数组、结构、枚举和函数定义的左大括号。Switch块缩进是为了防止下面的case语句出现“挂缩进”。
int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}
--style=mozilla / -A16:Mozilla风格 —— 使用linux大括号。开始的大括号与类、结构体、枚举和函数定义分开。大括号附加到函数中的所有其他内容,包括名称空间、数组和语句。这种样式经常与缩进2个空格和——break-return-type一起使用。
int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
} else
return 0;
}
2.Tab选项
default indent(如果没有设置缩进选项,将使用默认选项4个空格(eg::-s4/--indent=spaces=4)。)
void Foo() {
....if (isBar1
............&& isBar2) // indent of this line can be changed with min-conditional-indent
........bar();
}
--indent=spaces / --indent=spaces=# / -s#:每缩进使用#空格(eg::-s3/--indent=spaces=3)。#必须在2到20之间。不指定同default indent
void Foo() {
...if (isBar1
.........&& isBar2) // indent of this line can be changed with min-conditional-indent
......bar();
}
--indent=tab / --indent=tab=# / -t / -t#:使用制表符进行缩进,使用空格进行继续行对齐。这可以确保无论查看器的选项卡大小如何,代码都能正确显示。将每个缩进当作#空格(例如-t6 /——indent=tab=6)。#必须在2到20之间。如果没有设置#,将缩进处理为4个空格。
with indent=tab:
void Foo() {
> if (isBar1
> ........&& isBar2) // indent of this line can be changed with min-conditional-indent
> > bar();
}
with style=linux, indent=tab=8:
void Foo()
{
> if (isBar1
> ....&& isBar2) // indent of this line can NOT be changed with style=linux
> > bar();
}
--indent=force-tab / --indent=force-tab=# / -T / -T#:如果可能的话,使用所有制表符缩进。如果连续行不是偶数个制表符,将在末尾添加空格。将每个制表符视为#空格(例如-T6 /——indent=force-tab=6)。#必须在2到20之间。如果没有设置#,将制表符视为4个空格。
with indent=force-tab:
void Foo() {
> if (isBar1
> > > && isBar2) // indent of this line can be changed with min-conditional-indent
> > bar();
}
--indent=force-tab-x / --indent=force-tab-x=# / -xT / -xT#:这个force-tab选项允许将制表符长度设置为与缩进长度不同的长度。这可能会导致缩进同时包含制表符和空格。如果可能的话,制表符将用于缩进。如果不能使用制表符缩进,将使用空格代替。此选项设置制表符长度。将每个制表符视为#空格(例如-xT6 /——indent=force-tab-x=6。#必须在2到20之间。如果没有设置#,将制表符视为8个空格。为了改变缩进长度从默认的4空格选项"indent=force-tab"也必须使用。
with indent=force-tab-x (default tab length of 8 and default indent length of 4):
void Foo() {
....if (isBar1
> ....&& isBar2) // indent of this line can be changed with min-conditional-indent
> bar();
}
3.大括号修饰选项
--attach-namespaces / -xn:大括号总是附加在命名空间语句上。
namespace FooName {
...
}
--attach-classes / -xc: 大括号总是附加在类语句上。
class FooClass {
...
};
--attach-inlines / -xl:所有大括号都附加到类和结构的内联方法定义(仅c++)
class FooClass
{
void Foo() {
...
}
};
--attach-extern-c / -xk:将大括号附加到带大括号的extern "C"语句(仅c++)
#ifdef __cplusplus
extern "C" {
#endif
但是函数定义是按照要求的大括号样式进行格式化的:
extern "C" EXPORT void STDCALL Foo()
{}
--attach-closing-while / -xV:将'do-while'语句的'while'附加到右括号。这优先于大括号样式和break关闭大括号选项。
do
{
bar();
++x;
}
while x == 1;
becomes:
do
{
bar();
++x;
} while x == 1;
4.缩进选项
--indent-classes / -C:缩进'class'和'struct'访问修饰符'public:', 'protected:'和'private:'(仅c++)
class Foo
{
public:
Foo();
virtual ~Foo();
};
becomes:
class Foo
{
public:
Foo();
virtual ~Foo();
};
--indent-modifiers / -xG:缩进'class '和'struct'访问修饰符'public:', 'protected:'和'private:',缩进一半。如果与缩进类一起使用,这个选项将被忽略。(仅c++)
class Foo
{
public:
Foo();
virtual ~Foo();
};
becomes:
class Foo
{
public:
Foo();
virtual ~Foo();
};
--indent-switches / -S:缩进'switch'块,以便'case X:'语句在switch块中缩进。整个case块是缩进的。
switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}
becomes:
switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}
--indent-cases / -K:缩进'case X:'块从'case X:'头。不包含在块中的Case语句不缩进。
switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}
becomes:
switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}
--indent-namespaces / -N:向名称空间块添加额外的缩进
namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}
becomes:
namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}
--indent-after-parens / -xU:在包含开头圆括号'('或赋值'='的行后面缩进,包括函数定义、声明和返回语句。
void Foo(bool bar1,
bool bar2)
{
isLongFunction(bar1,
bar2);
isLongVariable = foo1
|| foo2;
}
becomes:
void Foo(bool bar1,
bool bar2)
{
isLongFunction(bar1,
bar2);
isLongVariable = foo1
|| foo2;
}
--indent-continuation=# / -xt#:设置以开始的圆括号'('或赋值'='结尾的行的延续缩进,包括函数定义和声明。它还将修改前面的缩进后括号选项。#的值表示大量的缩进。有效值是从0到4的整数值。如果不使用该选项,则使用默认值1。
isLongVariable =
foo1 ||
foo2;
isLongFunction(
bar1,
bar2);
becomes (with indent-continuation=3):
isLongVariable =
foo1 ||
foo2;
isLongFunction(
bar1,
bar2);
--indent-labels / -L:向标签添加额外的缩进,使它们显示比当前缩进少1个缩进,而不是向左刷新(默认)。
void Foo() {
while (isFoo) {
if (isFoo)
goto error;
...
error:
...
}}
becomes (with indented 'error:'):
void Foo() {
while (isFoo) {
if (isFoo)
goto error;
...
error:
...
}
}
--indent-preproc-block / -xW:缩进预处理器块在大括号级别0,并立即在名称空间内。对缩进的内容有限制。方法、类、数组等中的块不会缩进。包含大括号或多行定义语句的块将不会缩进。没有此选项,预处理器块不会缩进。
#ifdef _WIN32
#include <windows.h>
#ifndef NO_EXPORT
#define EXPORT
#endif
#endif
becomes:
#ifdef _WIN32
#include <windows.h>
#ifndef NO_EXPORT
#define EXPORT
#endif
#endif
--indent-preproc-define / -w:缩进以反斜杠结尾的多行预处理器定义。应该与 --convert-tabs一起使用,以获得正确的结果。做得很好,但不能在模糊预处理定义中执行奇迹。如果没有这个选项,预处理器语句将保持不变。
#define Is_Bar(arg,a,b) \
(Is_Foo((arg), (a)) \
|| Is_Foo((arg), (b)))
becomes:
#define Is_Bar(arg,a,b) \
(Is_Foo((arg), (a)) \
|| Is_Foo((arg), (b)))
--indent-preproc-cond / -xw:将预处理条件语句缩进到与源代码相同的级别。
isFoo = true;
#ifdef UNICODE
text = wideBuff;
#else
text = buff;
#endif
becomes:
isFoo = true;
#ifdef UNICODE
text = wideBuff;
#else
text = buff;
#endif
--indent-col1-comments / -Y:从第一列开始缩进c++注释。默认情况下,从第一列开始的c++注释被假定为注释输出代码,而不是缩进。此选项将允许注释与代码一起缩进。
void Foo()\n"
{// comment
if (isFoo)
bar();
}
becomes:
void Foo()\n"
{
// comment
if (isFoo)
bar();
}
--min-conditional-indent=# / -m#:
设置header由多行组成时添加的最小缩进。这种缩进有助于轻松地将header与后面的命令语句分开。#的值表示缩进的数量,并且是最小值。缩进可能更大,以与前一行的数据对齐。有效值为:
0 - 没有最小缩进。这些行将与前一行上的括号对齐。
1 - 至少缩进一个额外的缩进。
2 - 缩进至少两个额外的缩进。
3 - 至少要增加定单的一半。这用于大缩进(例如8)。
默认值是2,两个额外的缩进。
// default setting makes this non-braced code clear
if (a < b
|| c > d)
foo++;
// but creates an exaggerated indent in this braced code
if (a < b
|| c > d)
{
foo++;
}
becomes (when setting --min-conditional-indent=0):
// setting makes this non-braced code less clear
if (a < b
|| c > d)
foo++;
// but makes this braced code clearer
if (a < b
|| c > d)
{
foo++;
}
--max-continuation-indent=# / -M#:设置#空格的最大长度以缩进延续行。#表示列的数量,且不能小于40或大于120。如果没有设置,则使用默认值40。此选项将防止延续行向右延伸太远。设置更大的值将允许代码进一步向右扩展。
fooArray[] = { red,
green,
blue };
fooFunction(barArg1,
barArg2,
barArg3);
becomes (with larger value):
fooArray[] = { red,
green,
blue };
fooFunction(barArg1,
barArg2,
barArg3);
4.填充选项
--break-blocks / -f:在标题块周围填充空行(e.g. 'if', 'for', 'while'...).
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
becomes:
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
--break-blocks=all / -F:在标题块周围填充空行(e.g. 'if', 'for', 'while'...).处理关闭头文件块(e.g. 'else', 'catch')作为独立块。
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
becomes:
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
--pad-oper / -p:在运算符周围插入空格。这也会添加逗号。如果可能的话,行尾注释将保留在原始列中。注意,没有取消垫的选项。一旦被填充,它们就保持填充状态。
if (foo==2)
a=bar((b-c)*a,d--);
becomes:
if (foo == 2)
a = bar((b - c) * a, d--);
--pad-comma / -xg:在逗号后插入空格。如果使用pad-oper,则不需要加。行尾注释将保留在原始列中。
if (isFoo(a,b))
bar(a,b);
becomes:
if (isFoo(a, b))
bar(a, b);
--pad-paren / -P:在括号的外部和内部都插入空格填充。行尾注释将保留在原始列中。
if (isFoo((a+2), b))
bar(a, b);
becomes:
if ( isFoo ( ( a+2 ), b ) )
bar ( a, b );
--pad-paren-out / -d:只在括号外面插入空格填充。空的括号不会加衬垫。如果可能的话,行尾注释将保留在原始列中。这可以用下面的unpad-paren来删除不需要的空间。
if (isFoo((a+2), b))
bar(a, b);
becomes:
if (isFoo ( (a+2), b) )
bar (a, b);
--pad-first-paren-out / -xd:在序列的第一个圆括号周围只在外部插入空格填充。空的括号不会加衬垫。行尾注释将保留在原始列中。可以用unpad-paren删除不需要的空间。如果与pad‑paren或pad‑paren‑out一起使用,该选项将被忽略。
if (isFoo((a+2), b))
bar(a, b);
becomes:
if (isFoo ((a+2), b))
bar (a, b);
--pad-paren-in / -D:只在里面插入圆括号周围的空格。行尾注释将保留在原始列中。这可以用下面的unpad-paren来删除不需要的空间。
if (isFoo((a+2), b))
bar(a, b);
becomes:
if ( isFoo( ( a+2 ), b ) )
bar( a, b );
--pad-header / -H:在标题之间插入空格(e.g. 'if', 'for', 'while'...)和下面的括号。行尾注释将保留在原始列中。可以使用unpad-paren删除不需要的空格。
if(isFoo((a+2), b))
bar(a, b);
becomes:
if (isFoo((a+2), b))
bar(a, b);
--unpad-paren / -U:在内外两边去掉多余的填充空间。行尾注释将保留在原始列中。
if ( isFoo( ( a+2 ), b ) )
bar ( a, b );
becomes (with no padding option requested):
if(isFoo((a+2), b))
bar(a, b);
--delete-empty-lines / -xe:删除函数或方法中的空行。函数或方法之外的空行不会被删除。如果与break-blocks或break-blocks=all一起使用,它将删除除由break-blocks选项添加的行之外的所有行。
void Foo()
{
foo1 = 1;
foo2 = 2;
}
becomes:
void Foo()
{
foo1 = 1;
foo2 = 2;
}
--fill-empty-lines / -E:用前一行的空白填充空行。
--align-pointer=type / -k1
--align-pointer=middle / -k2
--align-pointer=name / -k3
将指针或引用操作符(*、&或^)附加到变量类型(左)或变量名称(右),或将其放在类型和名称(中间)之间。如果可能的话,将保留类型和名称之间的空格。这个选项适用于C/ c++、c++ /CLI和c#文件。要单独格式化引用,请使用以下align-reference选项。
char* foo1;
char & foo2;
string ^s1;
becomes (with align-pointer=type):
char* foo1;
char& foo2;
string^ s1;
char* foo1;
char & foo2;
string ^s1;
becomes (with align-pointer=middle):
char * foo1;
char & foo2;
string ^ s1;
char* foo1;
char & foo2;
string ^s1;
becomes (with align-pointer=name):
char *foo1;
char &foo2;
string ^s1;
--align-reference=none / -W0
--align-reference=type / -W1
--align-reference=middle / -W2
--align-reference=name / -W3
该选项将引用与指针分开对齐。指针不会被这个选项改变。如果指针和引用要对齐,请使用前面的对齐指针选项。选项align-reference=none不会改变引用对齐方式。其他选项与对齐指针相同。(仅C/ C++、c++ /CLI和C#文件)。
char &foo1;
becomes (with align-reference=type):
char& foo1;
char& foo2;
becomes (with align-reference=middle):
char & foo2;
char& foo3;
becomes (with align-reference=name):
char &foo3;
5.格式化选项
--break-closing-braces / -y:当与 --style=java, --style=kr, --style=stroustrup, --style=linux, 或者--style=1tbs同时使用,会打破关闭头文件 (e.g. 'else', 'catch', ...) 。结束标题花括号总是与其他样式一起断开。
void Foo(bool isFoo) {
if (isFoo) {
bar();
} else {
anotherBar();
}}
becomes (a broken 'else'):
void Foo(bool isFoo) {
if (isFoo) {
bar();
}
else {
anotherBar();
}
}
--break-elseifs / -e:将"else if"标题组合分隔成单独的行。如果使用keep-one-line语句,则此选项无效,“else if”语句将保持原样。
如果不使用此选项,"else If "标题组合将被放置在单行上。
if (isFoo) {
bar();
}
else if (isFoo1()) {
bar1();
}
else if (isFoo2()) {
bar2;
}
becomes:
if (isFoo) {
bar();
}
else
if (isFoo1()) {
bar1();
}
else
if (isFoo2()) {
bar2();
}
--break-one-line-headers / -xb:从位于同一行的语句中断开一行标题(e.g. 'if', 'while', 'else', ...)如果语句用大括号括起来,大括号将根据要求的大括号样式进行格式化。如果使用keep-one-line-statements,则多语句行不会被断开。如果使用keep-one-line-blocks,并且报头包含在块中,则一行块不会被打断。
void Foo(bool isFoo)
{
if (isFoo1) bar1();
if (isFoo2) { bar2(); }}
becomes:
void Foo(bool isFoo)
{
if (isFoo1)
bar1();
if (isFoo2) {
bar2();
}
}
--add-braces / -j:向不带大括号的单行条件语句添加大括号(例如:“如果”,“对”,“而”……)。大括号将根据要求的大括号样式添加。如果没有要求样式,将附加大括号。如果使用keep-one-line-statements,则不会将大括号添加到多语句行中。如果使用keep-one-line-blocks,则不会将大括号添加到一行块中。如果与--add-one-line-braces一起使用,结果将是一行大括号。
if (isFoo)
isFoo = false;
becomes:
if (isFoo) {
isFoo = false;
}
--add-one-line-braces / -J:添加一行大括号到不加大括号的一行条件语句 (e.g. 'if', 'for', 'while'...)。该选项意味--keep-one-line-blocks,并且不会打破一行块。
if (isFoo)
isFoo = false;
becomes:
if (isFoo)
{ isFoo = false; }
--remove-braces / -xj:从条件语句中删除括号(例如:“如果”,“对”,“而”……)。语句必须是单行上的单个语句。如果还使用--add-braces或--add-one-line-braces,结果将是添加大括号。大括号不会从"One True Brace Style"中删除,--style=1tbs。
if (isFoo)
{
isFoo = false;
}
becomes:
if (isFoo)
isFoo = false;
--break-return-type / -xB
--break-return-type-decl / -xD
从函数名中分离返回类型。这两个选项用于函数定义(-xB)和函数声明或签名(-xD)。如与--attach-return-type一起使用,结果将破坏返回类型。
void Foo(bool isFoo);
becomes:
void
Foo(bool isFoo);
--attach-return-type / -xf
--attach-return-type-decl / -xh
将返回类型附加到函数名。这两个选项用于函数定义(-xf)和函数声明或签名(-xh)。它们的目的是撤消--break-return-type选项。如果与--break-return-type一起使用,结果将打破返回类型。
void
Foo(bool isFoo);
becomes:
void Foo(bool isFoo);
--keep-one-line-blocks / -O:不要打断一行代码块。
if (isFoo)
{ isFoo = false; cout << isFoo << endl; }
remains unchanged.
--keep-one-line-statements / -o:不要打破复杂语句和驻留在一行中的多个语句。
if (isFoo)
{
isFoo = false; cout << isFoo << endl;
}
remains unchanged.
--convert-tabs / -c:将Tab转换为行非缩进部分中的空格。插入的空格数将保持制表符的间距。使用每个选项卡的空格的当前设置。如果在更改每个选项卡的空格时使用convert-tabs,可能不会产生预期的结果。制表符不会在引号内替换。
--close-templates / -xy:关闭模板定义结束尖括号之间的空白。
Stack< int, List< int > > stack1;
becomes:
Stack< int, List< int >> stack1;
--remove-comment-prefix / -xp:在以一行开头的多行注释中删除前面的'*'。如果末尾有'*',也会被删除。小于一个缩进的文本缩进为一个缩进。不改变大于一个缩进的文本。一行开头没有'*'的多行注释被缩进为一个缩进,以保持一致性。这可以略微修改注释掉代码块的缩进。包含所有'*'的行保持不变。注释关闭符'*/'将删除额外的空格。
/*
* comment line 1
* comment line 2
*/
becomes:
/*
comment line 1
comment line 2
*/
--max-code-length=# / -xC#
--break-after-logical / -xL
如果代码超过#字符,选项max‑code‑length将断行。有效值为50到200。没有逻辑条件的行会在逻辑条件(||,&&,…)、逗号、圆括号、分号或空格处中断。有些代码不会被破坏,比如注释、引号和数组。如果与keep‑one‑line‑blocks或add-one-line-braces一起使用,block不会被破坏。如果与keep‑one‑line‑statements一起使用,当行超过最大长度时,语句将以分号分隔。如果在最大代码长度内没有可用的断点,则该行将在最大代码长度之后的第一个可用断点处被中断。默认情况下,逻辑条件将放在新行的第一个位置。选项break‑after‑logical将导致逻辑条件被放在前一行的最后。如果没有最大代码长度,这个选项就不起作用。
if (thisVariable1 == thatVariable1 || thisVariable2 == thatVariable2 || thisVariable3 == thatVariable3)
bar();
becomes:
if (thisVariable1 == thatVariable1
|| thisVariable2 == thatVariable2
|| thisVariable3 == thatVariable3)
bar();
becomes (with break‑after‑logical):
if (thisVariable1 == thatVariable1 ||
thisVariable2 == thatVariable2 ||
thisVariable3 == thatVariable3)
bar();
--mode=c
--mode=cs
--mode=java
缩进一个C类型、c#或Java文件。C类型文件有C、c++、c++ /CLI和Objective-C。该选项通常从每个文件的文件扩展名设置。您可以使用此条目覆盖该设置。它将用于所有文件,而不管文件扩展名是什么。它允许格式化程序识别特定于语言的语法,如c++类、模板和关键字。