Part 2 - The Cppcheck data representation
Introduction
In this article I will discuss the data representation that Cppcheck
uses.
The data representation that Cppcheck uses is specifically designed
for static analysis. It is not intended to be generic and useful for other
tasks.
See the data
There are two ways to look at the data representation at
runtime.
Using --rule=.+ is one way.
All tokens are written on a line:
int a ; int b ;
Using --debug is another way.
The tokens are line separated in the same way as the original code:
1: int a@1 ;
2: int b@2 ;
In the --debug output there are
"@1" and "@2" shown. These are the
variable ids (Cppcheck gives each variable a unique id). You can ignore
these if you only plan to write rules with regular expressions, you can't
use variable ids with regular expressions.
In general, I will use the --rule=.+
output in this article because it is more compact.
Some of the simplifications
The data is simplified in many ways.
Preprocessing
The Cppcheck data is preprocessed. There are no comments, #define,
#include, etc.
Original source code:
#define SIZE 123
char a[SIZE];
The Cppcheck data for that is:
char a [ 123 ] ;
typedef
The typedefs are simplified.
typedef char s8;
s8 x;
The Cppcheck data for that is:
; char x ;
Calculations
Calculations are simplified.
int a[10 + 4];
The Cppcheck data for that is:
int a [ 14 ] ;
Variables
Variable declarations
Variable declarations are simplified. Only one variable can be
declared at a time. The initialization is also broken out into a
separate statement.
int *a=0, b=2;
The Cppcheck data for that is:
int * a ; a = 0 ; int b ; b = 2 ;
This is even done in the global scope. Even though that is
invalid in C/C++.
Known variable values
Known variable values are simplified.
void f()
{
int x = 0;
x++;
array[x + 2] = 0;
}
The --debug output for that
is:
1: void f ( )
2: {
3: ; ;
4: ;
5: array [ 3 ] = 0 ;
6: }
The variable x is removed because it is not used after the
simplification. It is therefore redundant.
The "known values" doesn't have to be numeric. Variable aliases,
pointer aliases, strings, etc should be handled too.
Example code:
void f()
{
char *a = strdup("hello");
char *b = a;
free(b);
}
The --debug output for that
is:
1: void f ( )
2: {
3: char * a@1 ; a@1 = strdup ( "hello" ) ;
4: ; ;
5: free ( a@1 ) ;
6: }
if/for/while
Braces in if/for/while-body
Cppcheck makes sure that there are always braces in if/for/while
bodies.
if (x)
f1();
The Cppcheck data for that is:
if ( x ) { f1 ( ) ; }
No else if
The simplified data representation doesn't have "else
if".
void f(int x)
{
if (x == 1)
f1();
else if (x == 2)
f2();
}
The --debug output:
1: void f ( int x@1 )
2: {
3: if ( x@1 == 1 ) {
4: f1 ( ) ; }
5: else { if ( x@1 == 2 ) {
6: f2 ( ) ; } }
7: }
Condition is always true / false
Conditions that are always true / false are simplified.
void f()
{
if (true) {
f1();
}
}
The Cppcheck data is:
void f ( ) { { f1 ( ) ; } }
Another example:
void f()
{
if (false) {
f1();
}
}
The debug output:
void f ( ) { }
Assignments
Assignments within conditions are broken out from the
condition.
void f()
{
int x;
if ((x = f1()) == 12) {
f2();
}
}
The x=f1() is broken out. The
--debug output:
1: void f ( )
2: {
3: int x@1 ;
4: x@1 = f1 ( ) ; if ( x@1 == 12 ) {
5: f2 ( ) ;
6: }
7: }
Replacing the "if" with "while" in the above example:
void f()
{
int x;
while ((x = f1()) == 12) {
f2();
}
}
The x=f1() is broken out twice. The
--debug output:
1: void f ( )
2: {
3: int x@1 ;
4: x@1 = f1 ( ) ; while ( x@1 == 12 ) {
5: f2 ( ) ; x@1 = f1 ( ) ;
5:
6: }
7: }
Comparison with >
Comparisons are simplified. The two conditions in this example
are logically the same:
void f()
{
if (x < 2);
if (2 > x);
}
Cppcheck data doesn't use > for
comparisons. It is converted into < instead. In
the Cppcheck data there is no difference for 2>x
and x<2.
1:
2: void f ( )
3: {
4: if ( x < 2 ) { ; }
5: if ( x < 2 ) { ; }
6: }
A similar conversion happens when >= is
used.
if (x) and if (!x)
If possible a condition will be reduced to x or !x. Here is an
example code:
void f()
{
if (!x);
if (NULL == x);
if (x == 0);
if (x);
if (NULL != x);
if (x != 0);
}
The --debug output is:
1: void f ( )
2: {
3: if ( ! x ) { ; }
4: if ( ! x ) { ; }
5: if ( ! x ) { ; }
6:
7: if ( x ) { ; }
8: if ( x ) { ; }
9: if ( x ) { ; }
10: }