For most of the refactoring options, you first need to select some code to refactor. Then right-click, select the Klocwork menu, and choose the appropriate refactoring option. You can also use keyboard shortcuts. For shortcuts, see:

• Visual Studio
• Eclipse

For Vim, the plug-in is not installed automatically with the Klocwork Desktop Analysis package. To configure it, see:

• Vim or gVim 7.2 or later

You can:

• rename entities whose scope is file-local, in order to make your identifier names more meaningful.
• extract methods or functions (with duplicate detection in Eclipse and Visual Studio) from large and unwieldy methods to create smaller and more logical functions. The newly extracted function is added to your source file, while the selected code is replaced with a call to that function.
• introduce variables (with duplicate detection in Eclipse and Visual Studio) to simplify complicated expressions. Occurrences of the expression are replaced with the new variable(s).
• inline variables, replacing all occurrences of a given variable with its initial value; this is the opposite of introducing variables.
• inline functions to remove the overhead of an overly segmented source layout. Typical candidates for inlining are simple functions that are called from few locations, but which might be invoked frequently at runtime, such as from an inner loop. These are functions that might best benefit from the overhead of function calling being removed. Inlining functions involves placing the method's body into the body of its caller(s) and removing the method.
• analyze headers, reporting missing transitive includes and unnecessary includes.
• optimize headers, applying any unused header and missing transitive header changes all in one step, without user confirmation.

To make identifier names more meaningful, rename a variable or function. Watch a demo. You can rename:

• local variables
• function parameters
• static functions and variables

The new name is checked against existing code to prevent hiding names of existing variables, functions, types, or namespaces, as well as naming conflicts.

int boo(int b) { 
}
int bar(int (*func)(char*)) { 		 
    return 1; 
} 
void foo(int a) { 
    int i = 2;
    i = 3;
    a = 567;
    a = boo(a); 
}

When you use the Extract Function option, a new function is created, and the selected code is inserted as the body of the function. The selected code must be a syntactically complete, non-empty sequence of complete statements and/or expressions.

int foo() {
  int a;
  /* selection starts -> */
  #define MY_MACRO 1
  a = MY_MACRO;
  /*<- selection ends*/
  a = a + 20;
  return a;
}

int extracted_function()
{
  int a;
  #define MY_MACRO 1
  a = MY_MACRO;
  return a;
}

int main() {		 
 int a;			       
   a++ ;			
  return a;
}

 void new_function(int *a) {  
  (*a)++ ; 
}
int main() { 
 int a; 
 new_function(&a) ; 
 return a; 
}

Introduce Variable allows you to quickly create a new local variable from the selected expression, initialize it with the expression, and replace all occurrences of the expression in the code with references to the newly introduced variable. The opposite action is to refactor by inlining a variable, which replaces the variable with its initial expression.

int main() { 				
    int c; 				     
    c = 1 +  2 + 3 + 4 + 5 ;		     
    return c; 				      
}

int main() { 
  int temp ; 
 int c;
  temp = 2 + 3 + 4 + 5 ; 
 c = 1 +  temp ;				     				  
 return c; 
}

Inline Variable allows you to replace all occurrences of a given variable with its initial value. The opposite action is to refactor by introducing a variable.

int main() { 
  int temp ; 
 int c;
  temp  = 2 + 3 + 4 + 5; 
 c = 1 +  temp ;				     				  
 return c; 
}

int main() { 				
    int c; 				     
    c = 1 +  2 + 3 + 4 + 5 ;		     
    return c; 				      
}

When you inline a function, the complete body of a function is inserted for each occurrence of the selected function.

Watch a demo of this feature here.

static int foo(int a) {			  
    int b = a + 2;				    
    return b;				      
}						  
int main() {				      
    int c;					     
    c =  foo(1) ;				 
    return c; 
} 

int main() { 
 int c;
  int a = 1;  
  int b = a + 2;  
  c = b; 
 return c;
}

#include <iostream>
 #include <stdio.h>
 #include <math.h>
 
 using namespace std;
 
 #define PI 3.14
 
 static float getArea(float radius) {
   float area = PI * *pow(radius, 2)*;
   return area;
 }

 class A{
    void foo() {...}
    void abc();
 }
 void A::abc()
 {
    foo(); //we can inline this
 
    A::foo(); //we can't inline this
    A x = new A();
    x->foo(); //we can't inline this
 }

Watch a demo of Analyze and Optimize Headers here.

Header Analysis allows you to fix problems with the include structure of your code, which can add to compile time and make the system difficult to maintain.

These problems can be solved with these two Klocwork refactorings:

Header Analysis allows you to fix problems with the include structure of your code, which can add to compile time and make the system difficult to maintain.

In Visual Studio, unnecessary or missing transitive includes are reported in the issue list as one of the following issues: HA.DUPLICATE, HA.OPTIMIZE or HA.UNUSED.

Note: There are no markers for header analysis issues.

1. To solve a Header Analysis issue manually, double-click on the issue found in the issues list. This will bring you to the line of code containing the issue.
2. Right-click the issue marker and a pop-up menu will appear with the following possible actions:

Once you make a change, the issue will disappear from the issue list.

If you prefer to make these changes automatically, you can right click anywhere in your current file and select Klocwork > Optimize headers. This will automatically fix all header issues within the current file.

To prevent these issues from appearing in the issue list see, disable the Header Analysis checkers.

If you are using one of the Visual Studio plug-ins, you can quickly refactor your code to remove unused functions.

A defined but unused function can lead to development confusion, such as the wrong function with a similar name being called. On rare occasions, the unused function can also find its way into the final executable, which can lead to other vulnerabilities. Klocwork provides two checkers that identify unused functions:

• UNUSED.FUNC.WARN
• UNUSED.FUNC.GEN

1. To fix one of these issues, right-click the issue marker on the left margin of the editor and choose one of the following actions:
   • For UNUSED.FUNC.WARN, choose Make this function static.
2. For UNUSED.FUNC.GEN, choose Remove unused function.

Klocwork Refactoring options can be accessed with the following shortcuts:

In Eclipse, you can fix header issues by using the Analyze Headers and Optimize Headers refactoring options by right-clicking anywhere in your current file and selecting Klocwork > Analyze Headers or Optimize Headers.

The Analyze Headers and Optimize Headers menu options are controlled by the Header Analysis checkers. If you disable these checkers, the header analysis refactoring will not be available.

When you use the Analyze Headers refactoring option, unnecessary or missing transitive includes are identified in the current file with a marker that activates a Quick Fix pop-up that provides a refactoring suggestion.

1. Right-click anywhere in your current file and select Klocwork > Analyze Headers. (You don't have to select any code to analyze your headers).
2. Click the bug marker or just scroll to your header files to see the Quick Fix icon: .
3. Click or use <Ctrl+1> to activate the Quick Fix pop-up.
4. Click the pop-up to proceed with the refactoring.

When you use the Optimize Headers refactoring option, all of the fixes are done for you without the need to go through and fix each individual marker in the file.

Klocwork Refactoring options can be accessed with the following shortcuts: