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).

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 lines¹. 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.