Idmadmin at 13:02, 22 April 2021

2021-04-22T13:02:29Z

Idmadmin: Created page with "Category:Coding tab The '''Astyle reformat''' option in the "Coding" tab opens the '''Artistic Style Formatter''' dialog. Here you can adjust artistic style settings befor..."

2017-08-29T15:10:44Z

Created page with "Category:Coding tab The '''Astyle reformat''' option in the "Coding" tab opens the '''Artistic Style Formatter''' dialog. Here you can adjust artistic style settings befor..."

New page

[[Category:Coding tab]]
The '''Astyle reformat''' option in the "Coding" tab opens the '''Artistic Style Formatter''' dialog. Here you can adjust artistic style settings before reformatting / beautifying the active source file according to the parameters you set. The number of indent spaces passed to Artistic Style is based on the '''Indent spaces''' value set in [[Settings:Editor:Word wrap/tab settings|Settings » Editor » Word wrap/tab settings]] (based upon extension of active file).
The '''Reformat''' button will apply the selected options/settings and reformat and beautify the active source file.

[[File:Ultraedit artistic style.png]]

===Indentation===
The following indentation options are available:

{|
!Control
!Function
|-
|Case
|indents 'case X:' blocks from the 'case X:' headers. Case statements not enclosed in blocks are NOT indented.

<pre>switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}</pre>

becomes:

<pre>switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}</pre>
|-
|Class
|indents 'class' and 'struct' blocks so that the blocks 'public:', 'protected:' and 'private:' are indented. The struct blocks are indented only if an access modifier is declared somewhere in the struct. The entire block is indented. This option is effective for C++ files only.

<pre>class Foo
{
public:
Foo();
virtual ~Foo();
};</pre>

becomes:

<pre>class Foo
{
public:
Foo();
virtual ~Foo();
};</pre>
|-
|Inline comments
|indents C++ comments beginning in column one. By default C++ comments beginning in column one are not indented. This option will allow the comments to be indented with the code.

<pre>void Foo()
{
// comment
if (isFoo)
bar();
}</pre>

becomes:

<pre>void Foo()
{
// comment
if (isFoo)
bar();
}</pre>
|-
|Label
|adds extra indentation to labels so they appear 1 indent less than the current indentation, rather than being flushed to the left (the default).

<pre>void Foo() {
while (isFoo) {
if (isFoo)
goto error;
...
error:
...
}
}</pre>

becomes (with indented 'error:'):

<pre>void Foo() {
while (isFoo) {
if (isFoo)
goto error;
...
error:
...
}
}</pre>
|-
|Namespace
|adds extra indentation to namespace blocks. This option has no effect on Java files.

<pre>namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}</pre>

becomes:

<pre>namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}</pre>
|-
|Preprocessor
|indents multi-line preprocessor definitions ending with a backslash. Should be used with '''Tabs -> Spaces''' for proper results. Does a pretty good job, but cannot perform miracles in obfuscated preprocessor definitions. Without this option the preprocessor statements remain unchanged.

<pre>#define Is_Bar(arg,a,b) \
(Is_Foo((arg), (a)) \
|| Is_Foo((arg), (b)))</pre>

becomes:

<pre>#define Is_Bar(arg,a,b) \
(Is_Foo((arg), (a)) \
|| Is_Foo((arg), (b)))</pre>
|-
|Switch
|indents 'switch' blocks so that the 'case X:' statements are indented in the switch block. The entire case block is indented.

<pre>switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}</pre>

becomes:

<pre>switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}</pre>
|-
|Max. instatement indent
|sets the maximum of # spaces to indent a continuation line. The # indicates a number of columns and must not be greater than 120. If no # is set, the default value of 40 will be used. A maximum of less than two indent lengths will be ignored. This option will prevent continuation lines from extending too far to the right. Setting a larger value will allow the code to be extended further to the right.

<pre>fooArray[] = { red,
green,
blue };
fooFunction(barArg1,
barArg2,
barArg3);</pre>

becomes (with larger value):

<pre>fooArray[] = { red,
green,
blue };
fooFunction(barArg1,
barArg2,
barArg3);</pre>
|-
|Min. conditional indent
|sets the minimal indent that is added when a header is built of multiple lines. This indent helps to easily separate the header from the command statements that follow. The value indicates a number of indents and is a minimum value. The indent may be greater to align with the data on the previous line.

The valid values are:

* '''0''': no minimal indent. The lines will be aligned with the parenthesis on the preceding line.
* '''1''': indent at least one additional indent.
* '''2''': indent at least two additional indents.
* '''3''': indent at least one-half an additional indent. This is intended for large indents (e.g. 8).

The default value is '''2''', two additional indents.

<pre>// default setting makes this non-bracketed code clear
if (a d)
foo++;

// but creates an exaggerated indent in this bracketed code
if (a d)
{
foo++;
}</pre>

becomes (when setting min. conditional indent = 0):

<pre>// setting makes this non-bracketed code less clear
if (a d)
foo++;

// but makes this bracketed code clearer
if (a d)
{
foo++;
}</pre>
|}

===Style===

One of sixteen possible styles may be selected using the Style dropdown ( allman, ansi, bsd, break, java, attach, kr, stroustrup, whitesmith, banner, gnu, linux, hortsmann, otbs, pico, lisp).

{|
|default
|If no bracket style option is set, the opening brackets will not be changed and closing brackets will be broken from the preceding line.
|-
|
* allman
* ansi
* bsd
* break

Allman style formatting/indenting uses broken brackets.
|
<pre>int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}</pre>
|-
|
* java
* attach
|Java style formatting/indenting uses attached brackets.

<pre>int Foo(bool isBar) {
if (isBar) {
bar();
return 1;
} else
return 0;
}</pre>
|-
|kr (Kernighan & Ritchie)
|Kernighan & Ritchie style formatting/indenting uses linux brackets. Brackets are broken from namespaces, classes, and function definitions. Brackets are attached to statements within a function.

<pre>int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
} else
return 0;
}</pre>
|-
|stroustrup
|Stroustrup style formatting/indenting uses stroustrup brackets. Brackets are broken from function definitions only. Brackets are attached to namespaces, classes, and statements within a function. This style frequently is used with an indent of 5 spaces.

<pre>int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
} else
return 0;
}</pre>
|-
|whitesmith
|Whitesmith style formatting/indenting uses broken, indented brackets. Class blocks and switch blocks are indented to prevent a 'hanging indent' with switch statements and C++ class modifiers (public, private, protected).

<pre>int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}</pre>
|-
|banner
|Banner style formatting/indenting uses attached, indented brackets. Class blocks and switch blocks are indented to prevent a 'hanging indent' with switch statements and C++ class modifiers (public, private, protected).

<pre>int Foo(bool isBar) {
if (isBar) {
bar();
return 1;
}
else
return 0;
}</pre>
|-
|gnu
|GNU style formatting/indenting uses broken brackets and indented blocks. This style frequently is used with an indent of 2 spaces.

Extra indentation is added to blocks '''within a function'''. The opening bracket for namespaces, classes, and functions is not indented.

<pre>int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}</pre>
|-
|linux
|Linux style formatting/indenting uses linux brackets. Brackets are broken from namespace, class, and function definitions. Brackets are attached to statements within a function. '''Min. conditional indent''' is one-half indent. If you want a different minimum conditional indent use the K&R style instead. This style works best with a large indent. It frequently is used with an indent of 8 spaces.

Also known as Kernel Normal Form (KNF) style, this is the style used in the Linux kernel.

<pre>int Foo(bool isBar)
{
if (isFoo) {
bar();
return 1;
} else
return 0;
}</pre>
|-
|horstmann
|Horstmann style formatting/indenting uses run-in brackets, brackets are broken and allow run-in statements. Switches are indented to allow a run-in to the opening switch block. This style frequently is used with an indent of 3 spaces.

<pre>int Foo(bool isBar)
{ if (isBar)
{ bar();
return 1;
} else
return 0;
}</pre>
|-
|otbs
|"One True Brace Style" formatting/indenting uses linux brackets and adds brackets to unbracketed one line conditional statements. In the following example brackets have been added to the "return 0;" statement. The option '''add one line brackets''' can also be used with this style.

<pre>int Foo(bool isBar)
{
if (isFoo) {
bar();
return 1;
} else {
return 0;
}
}</pre>
|-
|pico
|Pico style formatting/indenting uses run-in brackets, opening brackets are broken and allow run-in statements. The closing bracket is attached to the last line in the block. Switches are indented to allow a run-in to the opening switch block. The style implies '''keep one line blocks''' and '''keep one line statements'''. This style does not support multiple-line brackets. If '''add brackets''' is used they will be added as '''one line brackets'''. This style frequently is used with an indent of 2 spaces.

<pre>int Foo(bool isBar)
{ if (isBar)
{ bar();
return 1; }
else
return 0; }</pre>
|-
|lisp
|Lisp style formatting/indenting uses attached brackets, opening brackets are attached at the end of the statement. The closing bracket is attached to the last line in the block. The style implies '''keep one line statements''' but NOT '''keep one line blocks'''. This style does not support one line brackets. If '''add one line brackets''' is used they will be added as multiple-line brackets.

<pre>int Foo(bool isBar) {
if (isBar) {
bar()
return 1; }
else
return 0; }</pre>
|}

===Mode===

This option is usually set from the file extension for each file. You can override the setting with this entry. It will be used for all files regardless of the file extension. It allows the formatter to identify language specific syntax such as C++ classes, templates, and keywords.

{|
|c
|indents a C or C++ file
|-
|cs
|indents a C# file
|-
|java
|indents a Java file
|}

===Options file===

An '''optional''' default options file may be used to supplement or replace the dialog options. The dialog options have precedence. If there is a conflict between a dialog option and an option in the default options file, the dialog option will be used.

Artistic Style looks for this file in the following locations (in order):
# the file indicated by the '''--options=''' command line option as used if an options file is set in the dialog;
# the file and directory indicated by the environment variable '''ARTISTIC_STYLE_OPTIONS''' (if it exists);
# the file named '''.astylerc''' in the directory pointed to by the '''HOME''' environment variable (e.g. "$HOME/.astylerc" on Linux);
# the file named '''astylerc''' in the directory pointed to by the '''USERPROFILE''' environment variable (e.g. "%USERPROFILE%\astylerc" on Windows).

===Formatting===

The following formatting options are available:

{|
!Control
!Function
|-
|Add brackets
|adds brackets to unbracketed one line conditional statements (e.g. 'if', 'for', 'while', ...). The statement must be on a single line. The brackets will be added according to the currently requested predefined style or bracket type. If no style or bracket type is requested the brackets will be attached. If '''add one line brackets''' is also used the result will be one line brackets.

<pre>if (isFoo)
isFoo = false;</pre>

becomes:

<pre>if (isFoo) {
isFoo = false;
}</pre>
|-
|Add one line brackets
|adds one line brackets to unbracketed one line conditional statements (e.g. 'if', 'for', 'while', ...). The statement must be on a single line. The option implies '''keep one line blocks''' and will not break the one line blocks.

<pre>if (isFoo)
isFoo = false;</pre>

becomes:

<pre>if (isFoo)
{ isFoo = false; }</pre>
|-
|Align pointer
|attaches a pointer or reference operator (*, &, or ^) to either the variable type (left) or variable name (right), or place it between the type and name (middle). The spacing between the type and name will be preserved, if possible. This option is for C/C++, C++/CLI, and C# files. To format references separately use the following '''align''' reference option.

<pre>char* foo1;
char & foo2;
String ^s1;</pre>

becomes (with align pointer = type):

<pre>char* foo1;
char& foo2;
String^ s1;</pre>

<pre>char* foo1;
char & foo2;
String ^s1;</pre>

becomes (with align pointer = middle):

<pre>char * foo1;
char & foo2;
String ^ s1;</pre>

<pre>char* foo1;
char & foo2;
String ^s1;</pre>

becomes (with align pointer = name):

<pre>char *foo1;
char &foo2;
String ^s1;</pre>
|-
|Align reference
|aligns references separate from pointers. Pointers are not changed by this option. If pointers and references are to be aligned the same, use the previous '''align pointer''' option. The align reference option with value none will not change the reference alignment. The other options are the same as for '''align pointer'''. This option is for C/C++, C++/CLI, and C# files.

<pre>char &foo1;</pre>

becomes (with align reference = type):

<pre>char& foo1;</pre>

<pre>char& foo2;</pre>

becomes (with align reference = middle):

<pre>char & foo2;</pre>

<pre>char& foo3;</pre>

becomes (with align reference = name):

<pre>char &foo3;</pre>
|-
|Break after logical
|The option '''max. code length''' will break a line if the code exceeds # characters. The valid values are '''50''' thru '''200'''. Lines without logical conditionals will break on a logical conditional (<nowiki>||</nowiki> , &&, ...), comma, parenthesis, semicolon, or space.

Some code will not be broken, such as comments, quotes, and arrays. If used with '''keep one line blocks''' or '''add one line brackets''' the blocks will NOT be broken. If used with keep one line statements the statements will be broken at a semicolon if the line goes over the maximum length. If there is no available break point within the max code length, the line will be broken at the first available break point after the max code length.

By default logical conditionals will be placed first on the new line. The option '''break after logical''' will cause the logical conditionals to be placed last on the previous line. This option has no effect without '''max. code length'''.

<pre>if (thisVariable1 == thatVariable1 || thisVariable2 == thatVariable2 || thisVariable3 == thatVariable3)
bar();</pre>

becomes:

<pre>if (thisVariable1 == thatVariable1
|| thisVariable2 == thatVariable2
|| thisVariable3 == thatVariable3)
bar();</pre>

becomes (with break after logical):

<pre>if (thisVariable1 == thatVariable1 ||
thisVariable2 == thatVariable2 ||
thisVariable3 == thatVariable3)
bar();</pre>
|-
|Break else if()
|breaks 'else if' header combinations into separate lines. This option has no effect if '''keep one line statements''' is used, the 'else if' statements will remain as they are. If this option is NOT used, 'else if' header combinations will be placed on a single line.

<pre>if (isFoo) {
bar();
}
else if (isFoo1()) {
bar1();
}
else if (isFoo2()) {
bar2;
}</pre>

becomes:

<pre>if (isFoo) {
bar();
}
else
if (isFoo1()) {
bar1();
}
else
if (isFoo2()) {
bar2();
}</pre>
|-
|Break blocks
|The '''default''' option pads empty lines around header blocks (e.g. 'if', 'for', 'while', ...).

<pre>isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;</pre>

becomes:

<pre>isFoo = true;

if (isFoo) {
bar();
} else {
anotherBar();
}

isBar = false;</pre>

The '''all''' option pads empty lines around header blocks (e.g. 'if', 'for', 'while', ...). Treat closing header blocks (e.g. 'else', 'catch') as stand-alone blocks.

<pre>isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;</pre>

becomes:

<pre>isFoo = true;

if (isFoo) {
bar();

} else {
anotherBar();
}

isBar = false;</pre>
|-
|Close templates
|closes whitespace in the angle brackets of template definitions. Closing the ending angle brackets is now allowed by the C++11 standard. Be sure your compiler supports this before making the changes.

<pre>Stack< int,List< int > > stack1;</pre>

becomes:

<pre>Stack<int,List<int>> stack1;</pre>
|-
|Empty lines
|The delete option deletes empty lines within a function or method. Empty lines outside of functions or methods are NOT deleted. If used with '''break blocks''' with '''default''' or '''all''' it will delete all lines EXCEPT the lines added by the '''break blocks''' options.

<pre>void Foo()
{

foo1 = 1;

foo2 = 2;

}</pre>

becomes:

<pre>void Foo()
{
foo1 = 1;
foo2 = 2;
}</pre>

The fill option fills empty lines with the white space of the previous line.
|-
|Keep one line blocks
|will not break one line blocks.

<pre>if (isFoo)
{ isFoo = false; cout << isFoo << endl; }</pre>

remains unchanged.
|-
|Keep one line statements
|will not break complex statements and multiple statements residing on a single line.

<pre>if (isFoo)
{
isFoo = false; cout << isFoo << endl;
}</pre>

remains unchanged.

<pre>if (isFoo) DoBar();</pre>

remains also unchanged.
|-
|Max code length
|The option '''max code length''' will break a line if the code exceeds # characters. The valid values are 50 thru 200. Lines without logical conditionals will break on a logical conditional (<nowiki>||</nowiki>, &&, ...), comma, parenthesis, semicolon, or space.

Some code will not be broken, such as comments, quotes, and arrays. If used with '''keep one line blocks''' or '''add one line brackets''' the blocks will NOT be broken. If used with '''keep one line statements''' the statements will be broken at a semicolon if the line goes over the maximum length. If there is no available break point within the max code length, the line will be broken at the first available break point after the max code length.
|-
|Space padding
|There are several padding options available:

'''first-paren-out''' 
inserts space padding around the first parenthesis in a series on the outside only. Any end of line comments will remain in the original column, if possible. This can be used with '''unpad-paren''' below to remove unwanted spaces. If used with '''pad-paren''' or '''pad-paren-out''', this option will be ignored. If used with '''pad-paren-in''', the result will be the same as '''pad-paren'''.

<pre>if (isFoo((a+2), b))
bar(a, b);</pre>

becomes:

<pre>if (isFoo ((a+2), b))
bar (a, b);</pre>

'''oper''' 
inserts space padding around operators. Any end of line comments will remain in the original column, if possible. Note that there is no option to unpad. Once padded, they stay padded.

<pre>if (foo==2)
a=bar((b-c)*a,d--);</pre>

becomes:

<pre>if (foo == 2)
a = bar((b - c) * a, d--);</pre>

'''paren''' 
inserts space padding around parenthesis on both the outside and the inside. Any end of line comments will remain in the original column, if possible.

<pre>if (isFoo((a+2), b))
bar(a, b);</pre>

becomes:

<pre>if ( isFoo ( ( a+2 ), b ) )
bar ( a, b );</pre>

'''paren-in''' 
inserts space padding around parenthesis on the '''inside''' only. Any end of line comments will remain in the original column, if possible. This can be used with unpad-paren below to remove unwanted spaces.

<pre>if (isFoo((a+2), b))
bar(a, b);</pre>

becomes:

<pre>if ( isFoo( ( a+2 ), b ) )
bar( a, b );</pre>

'''paren-out''' 
inserts space padding around parenthesis on the '''outside''' only. Any end of line comments will remain in the original column, if possible. This can be used with '''unpad-paren''' below to remove unwanted spaces.

<pre>if (isFoo((a+2), b))
bar(a, b);</pre>

becomes:

<pre>if (isFoo ( (a+2), b) )
bar (a, b);</pre>

'''header''' 
inserts space padding after parenthesis headers only (e.g. 'if', 'for', 'while', ...). Any end of line comments will remain in the original column, if possible. This can be used with '''unpad-paren''' to remove unwanted spaces.

<pre>if(isFoo((a+2), b))
bar(a, b);</pre>

becomes:

<pre>if (isFoo((a+2), b))
bar(a, b);</pre>

'''unpad-paren''' 
removes extra space padding around parenthesis on the inside and outside. Any end of line comments will remain in the original column, if possible. This option can be used in combination with the parenthesis padding options '''paren''', '''paren-out''', '''paren-in''', and '''header''' above. Only padding that has not been requested by other options will be removed.

For example, if a source has parenthesis padded on both the inside and outside, and you want inside only. You need to use '''unpad-paren''' to remove the outside padding, and '''paren-in''' to retain the inside padding. Using only '''paren-in''' would not remove the outside padding.

<pre>if ( isFoo( ( a+2 ), b ) )
bar ( a, b );</pre>

becomes (with no padding option requested):

<pre>if(isFoo((a+2), b))
bar(a, b);</pre>
|-
|Tabs -> Spaces
|converts tabs into spaces in the non-indentation part of the line. The number of spaces inserted will maintain the spacing of the tab. The current setting for spaces per tab is used. It may not produce the expected results if this option is used when changing spaces per tab. Tabs are not replaced in quotes.
|}

@@ Line 1: / Line 1: @@
 [[Category:Coding tab]]
-The '''Astyle reformat''' option in the "Coding" tab opens the '''Artistic Style Formatter''' dialog. Here you can adjust artistic style settings before reformatting / beautifying the active source file according to the parameters you set. The number of indent spaces passed to Artistic Style is based on the '''Indent spaces''' value set in [[Settings:Editor:Word wrap/tab settings|Settings &raquo; Editor &raquo; Word wrap/tab settings]] (based upon extension of active file).
+The '''Astyle reformat''' option in the "Coding" tab opens the '''Artistic Style Formatter''' dialog. Here you can adjust artistic style settings before reformatting / beautifying the active source file according to the parameters you set. The number of indent spaces passed to Artistic Style is based on the '''Indent spaces''' value set in [[Settings:Editor:Word_wrap_/_tab_settings|Settings &raquo; Editor &raquo; Word wrap/tab settings]] (based upon extension of active file).
 The '''Reformat''' button will apply the selected options/settings and reformat and beautify the active source file.

Astyle reformat - Revision history

Idmadmin at 13:02, 22 April 2021

Idmadmin: Created page with "Category:Coding tab The '''Astyle reformat''' option in the "Coding" tab opens the '''Artistic Style Formatter''' dialog. Here you can adjust artistic style settings befor..."