12,767,912 members (52,157 online)
alternative version

#### Stats

77.9K views
34 bookmarked
Posted 16 Jun 2005

# Cyclomatic Complexity Viewer

, 30 Jun 2005
 Rate this:
A Cyclomatic complexity viewer application.

## Introduction

The Cyclomatic Complexity Metric[1] "measures the amount of decision logic in a single software module"[2]. In my implementation I have taken the software module to be a function. The cyclomatic complexity "is based entirely on the structure of the software's control flow graph" [2]. The formula for calculating the cyclomatic complexity for each function using its control flow graph is:

where E and N are the number of edges and nodes in the control flow graph, respectively. Figure 1 displays the control flow graphs for the control structures found in the C++ language except for `for`. My understanding of the Cyclomatic Complexity Metric is that it measures how complex a function is and this determines how easy it will be to test the specific function.

 if if/else while do switch

Figure 1. Control flow graphs

## Background

At last after nearly five years of working on this add-in, I have finally released it. Why five years you may ask? Well after finding and implementing an algorithm to display directed graphs, improving the program, then discovering Graphviz, losing all the source code and starting from the beginning again, it has taken me that long. For the VC++ 6 version of the add-in, I have made use of Norm Almond's CLabel class. In the VS.NET 2003 version, I made use of Rashid Thadha's ATL version of the CLabel class.

### VS.NET 2003

1. Extract the files using the folder names.
2. Double-click on the ReCreateCommands.reg file to register the add-in. After installation, the following buttons should appear on the toolbar: .
3. If nothing appears, click on the Tools menu item and select Add-in Manager... from the dropdown menu. The Add-in Manager dialog will appear. Now make sure that both the boxes for the Available Add-ins and the Startup are selected. The toolbar should appear now.
4. Also look at the View\Toolbars menu item and select Metric Viewer from the list.
5. If still nothing appears then try devenv.exe /setup.

### VC++ 6

1. Extract the files using the folder names.
2. Click on the Tools menu item and select Customize... from the dropdown menu. The Customize dialog will appear. Click on the Add-ins and Macro Files tab. Click the checkbox labeled CycloComplexViewer Add-In to enable it.
3. The following button will appear:

## Warning

This add-in is very buggy at the moment. It has a number of problems that still need to be fixed. Below is a list of the problems:

1. It cannot parse source code in the form of:
`if (A) D;`

or

`if (B) {C};`

However it will be able to parse source code in the form of:

```if (A)
D;```

or

```if (B)
{C}```
2. The list display in the dialog does not automatically update when the scroll buttons are manipulated. It only updates itself once one scrolls down the list using the vertical scrollbars.

### VS.NET 2003

Both buttons are used to calculate a cyclomatic complexity metric, however the matrices calculated are those of:

respectively.

#### A Specific Function

The first button is used when you want to find out the cyclomatic complexity metric of a specific function. Just select the specific function and click the button. As shown in Figure 2(a) and 2(b), a dialog with the name of the function and its specific metric is displayed. If the metric value is greater than 10 the value is displayed in red, otherwise it is displayed in black.

 Figure 2(a). Less than 10 Figure 2(b). Greater than 10

Figure 2. Metric for a specific selected function

#### All Functions of a Solution

The second button will calculate the cyclomatic complexity matrices of all the (global and member) functions found in the currently loaded Solution. Just click the button. As shown in Figure 3, a dialog with a list control containing all the functions in the Solution and their respective matrices is displayed.

In addition to the list, the dialog has a number of controls which can be used to manipulate the data.

Figure 4 shows the control that is used to set the metric level for comparisons. Initially it is set to the default value of 10. A number of people have recommended that a value of 10 is taken as the default level against which to compare cyclomatic complexity matrices of functions. Any function with a metric value higher than 10 is considered to be too complex and needs to be broken up into a number of smaller functions. The table below gives some idea:

 1-10 - a simple program 11-20 - more complex 21-50 - complex > 50 - untestable[3]

All functions with a metric value higher than the currently set metric level will be highlighted in the list. Figure 5 shows the results of applying the add-in to a currently loaded Solution and then setting the metric level to 5.

 Figure 4. Default metric level of 10 Figure 5. Metric level set at 5 (Click here to enlarge)

Figure 6 shows the 'Export' button which can be used to have the results, as displayed in the list, exported to a pre-named XML file.

Figure 6. Export results to an XML file

The XML file has the following format:

```<solution name="">
<project name="">
<class name="">
<file name="">
<function name="">
<path name=""></path>
<metric></metric>
</function>
</file>
</class>
</project>
<project name="">
...
</project>
...
</solution>```

### VC++ 6

The VC++ 6 version of the add-in can only determine the cyclomatic complexity metric for a single function. Select the function by highlighting the code for the specific function. Then click on the Add-in button and a dialog as in Figure 7 will appear displaying the metric value. If the metric value is greater than 10 the value is displayed in red, otherwise it is displayed in black.

Figure 7. Metric value of a specific selected function

## Feedback

I will gladly appreciate any comments, suggestions, especially if it helps me fix the problems as stated in the Warning section.

## History

• 24 June 2005 - Added files for VC++ 6 version and updated article.
• 17 June 2005 - First public release.

A list of licenses authors might use can be found here

## Share

 United Kingdom
I am a qualified Veterinary Surgeon who prefers treating computers with viruses than animals with viruses. I have recently completed a MEng German Informatics degree at the University of Reading with a 2:1. I also have the ISEB Foundation Certificate in Software Testing.

Currently I am umemployed and desparately looking for a job in the IT industry.

## You may also be interested in...

 First Prev Next
 about the computation of cyclomatic complexity and construction of control flow graph suraj karki30-Apr-09 0:56 suraj karki 30-Apr-09 0:56
 Not able to use the dll with Visual Studio 8.0 Venki259-Jul-07 23:26 Venki25 9-Jul-07 23:26
 Missing Code Tim Tinker13-Jan-06 6:52 Tim Tinker 13-Jan-06 6:52
 Re: Missing Code Franz Klein13-Jan-06 8:08 Franz Klein 13-Jan-06 8:08
 Re: Missing Code Franz Klein14-Jan-06 1:23 Franz Klein 14-Jan-06 1:23
 DLL failed to load James Hulsey5-Jul-05 7:56 James Hulsey 5-Jul-05 7:56
 Re: DLL failed to load Anonymous7-Jul-05 1:34 Anonymous 7-Jul-05 1:34
 Re: DLL failed to load Franz Klein7-Jul-05 1:45 Franz Klein 7-Jul-05 1:45
 Re: DLL failed to load James Hulsey7-Jul-05 8:18 James Hulsey 7-Jul-05 8:18
 the DLL for VC7 is a debug version volatileMike1-Jul-05 6:17 volatileMike 1-Jul-05 6:17
 Simplifying the parser Jose Lamas Rios19-Jun-05 17:42 Jose Lamas Rios 19-Jun-05 17:42
 Related to the problems you mention in the "Warning" section, you may consider using lex/yacc utilities or their Flex/Bison equivalents. They greatly simplify the task of creating parsers and compilers.The Lex & Yacc Page[^][UPDATE] Forget about the above paragraph. Looking at the list of your articles I can see you are fully aware of these tools Besides, if you only want to obtain the metrics, chapter V in "A Complexity Measure, by McCabe[^] points to a handy simplification in the case of structured programs: instead of calculating the complexity from the graph structure (the edges and nodes formula), it's easier to calculate it as the number of decision control keywords (`if`, `while`, `for`, etc.) plus one. Strictly speaking, you'd also need to look into the conditions governing those keywords.Quote:In practice compound predicates such as `IF "C1 AND C2" THEN `are treated as contributing two to complexity since without the connective `AND` we would have `IF C1 THEN IF C2 THEN` which has two predicates.This means you'd also need to add one for every logical operator inside a condition immediately after a decision control keyword.With this in mind, once the parser recognizes it's inside a particular function, and until its end, it just needs to count the relevant keywords, the logical operators in their conditions (which are right after each keyword), and add one at the end. It doesn't actually need to recognize and make sense of each and every sintactical piece.Hope this helps, -- jlrhttp://jlamas.blogspot.com/[^]
 Re: Simplifying the parser Franz Klein24-Jun-05 4:40 Franz Klein 24-Jun-05 4:40
 Cannot load dll Rage17-Jun-05 2:26 Rage 17-Jun-05 2:26
 Re: Cannot load dll Franz Klein17-Jun-05 4:31 Franz Klein 17-Jun-05 4:31