Next: , Previous: Custom Auto-newlines, Up: Top

9 Clean-ups

Clean-ups are mechanisms which remove (or exceptionally, add) whitespace in specific circumstances and are complementary to colon and brace hanging. You enable a clean-up by adding its symbol into c-cleanup-list, e.g., like this:

     (add-to-list 'c-cleanup-list 'space-before-funcall)

On the surface, it would seem that clean-ups overlap the functionality provided by the c-hanging-*-alist variables. Clean-ups, however, are used to adjust code “after-the-fact”, i.e., to adjust the whitespace in constructs later than when they were typed.

Most of the clean-ups remove automatically inserted newlines, and are only active when auto-newline minor mode is turned on. Others will work all the time. Note that clean-ups are only performed when there is nothing but whitespace appearing between the individual components of the construct, and (apart from comment-close-slash) when the construct does not occur within a literal (see Auto-newlines).

— User Option: c-cleanup-list

You configure CC Mode's clean-ups by setting the style variable c-cleanup-list, which is a list of clean-up symbols. By default, CC Mode cleans up only the scope-operator construct, which is necessary for proper C++ support.

These are the clean-ups that are only active when electric and auto-newline minor modes are enabled:

brace-else-brace
Clean up ‘} else {’ constructs by placing the entire construct on a single line. Clean up occurs when the open brace after the ‘else’ is typed. So for example, this:
          void spam(int i)
          {
              if( i==7 ) {
                  dosomething();
              }
              else
              {

appears like this after the last open brace is typed:

          void spam(int i)
          {
              if( i==7 ) {
                  dosomething();
              } else {

brace-elseif-brace
Similar to the brace-else-brace clean-up, but this cleans up ‘} else if (...) {’ constructs. For example:
          void spam(int i)
          {
              if( i==7 ) {
                  dosomething();
              }
              else if( i==3 )
              {

appears like this after the last open parenthesis is typed:

          void spam(int i)
          {
              if( i==7 ) {
                  dosomething();
              } else if(

and like this after the last open brace is typed:

          void spam(int i)
          {
              if( i==7 ) {
                  dosomething();
              } else if( i==3 ) {

brace-catch-brace
Analogous to brace-elseif-brace, but cleans up ‘} catch (...) {’ in C++ and Java mode.
empty-defun-braces
Clean up braces following a top-level function or class definition that contains no body. Clean up occurs when the closing brace is typed. Thus the following:
          class Spam
          {
          }

is transformed into this when the close brace is typed:

          class Spam
          {}

defun-close-semi
Clean up the terminating semicolon on top-level function or class definitions when they follow a close brace. Clean up occurs when the semicolon is typed. So for example, the following:
          class Spam
          {
          ...
          }
          ;

is transformed into this when the semicolon is typed:

          class Spam
          {
          ...
          };

list-close-comma
Clean up commas following braces in array and aggregate initializers. Clean up occurs when the comma is typed. The space before the comma is zapped just like the space before the semicolon in defun-close-semi.
scope-operator
Clean up double colons which might designate a C++ scope operator split across multiple lines1. Clean up occurs when the second colon is typed. You will always want scope-operator in the c-cleanup-list when you are editing C++ code.
one-liner-defun
Clean up a single line of code enclosed by defun braces by removing the whitespace before and after the code. The clean-up happens when the closing brace is typed. If the variable c-max-one-liner-length is set, the cleanup is only done if the resulting line would be no longer than the value of that variable.

For example, consider this AWK code:

          BEGIN {
              FS = "\t" # use <TAB> as a field separator
          }

It gets compacted to the following when the closing brace is typed:

          BEGIN {FS = "\t"} # use <TAB> as a field separator
— User Option: c-max-one-liner-length

The maximum length of the resulting line for which the clean-up one-liner-defun will be triggered. This length is that of the entire line, including any leading whitespace and any trailing comment. Its default value is 80. If the value is zero or nil, no limit applies.

The following clean-ups are always active when they occur on c-cleanup-list, regardless of whether Electric minor mode or Auto-newline minor mode are enabled:

space-before-funcall
Insert a space between the function name and the opening parenthesis of a function call. This produces function calls in the style mandated by the GNU coding standards, e.g., ‘signal (SIGINT, SIG_IGN)’ and ‘abort ()’. Clean up occurs when the opening parenthesis is typed. This clean-up should never be active in AWK Mode, since such a space is syntactically invalid for user defined functions.
compact-empty-funcall
Clean up any space between the function name and the opening parenthesis of a function call that has no arguments. This is typically used together with space-before-funcall if you prefer the GNU function call style for functions with arguments but think it looks ugly when it's only an empty parenthesis pair. I.e., you will get ‘signal (SIGINT, SIG_IGN)’, but ‘abort()’. Clean up occurs when the closing parenthesis is typed.
comment-close-slash
When inside a block comment, terminate the comment when you type a slash at the beginning of a line (i.e., immediately after the comment prefix). This clean-up removes whitespace preceding the slash and if needed, inserts a star to complete the token ‘*/’. Type C-q / in this situation if you just want a literal ‘/’ inserted.

Footnotes

[1] Certain C++ constructs introduce ambiguous situations, so scope-operator clean-ups might not always be correct. This usually only occurs when scoped identifiers appear in switch label tags.