Mukund’s adventures

Try Sparse to analyze your C code. Unlike Splint, it works well with the GTK libraries and reports a wide range of issues. It also neatly fits in with the autotools build system, so you can basically run your autotools and prep for a make, and then call:

make CC=cgcc

cgcc is a wrapper which invokes sparse first, and then gcc. Then go through the warnings and fix them.

It would be very worthwhile for someone to add support for variadic macros to Splint (a C static analysis tool similar to lint but better). While it is not as good as Coverity Prevent and generates several false positives, it can be made to work with GLib/GTK+ application code and would be very helpful in eliminating several types of programming errors. It is certainly much better than lint. It has been used on GIMP trunk, along with other static analysis tools and it found errors which were fixed. Another tool called href=”http://www.cubewano.org/oink”>Oink doesn’t compile on my x86_64 box, but seems interesting nevertheless as it claims to support C++.

I dream of a day when C/C++ programmer editors do static analysis as I type, and suggest corrections to stupid mistakes. NetBeans (Java) has really spoiled me, by how productive one can be using it.

char*a=" $#,.';:nt",*s="�000at�31r1�20�21�05",*d="215266333
S3�32�04321232L32176233346;346�30J~G200317251373O�01237h
3371C233317211274317371�23364235�33314377221276a360371
f~341342303326361277353~O207307h337365277\"�34o304ygb
3146317333|�33355�03�16�333063773411264�04375�336202a
242~3061",i,j,r=0,b=0;main(){for(i=0;i<98;i++){for(;;){r<<=1;r|=(*(d+i)
>>(7-b++))&1;for(j=0;j<10;j++) if(*(s+j)==r){putchar(*(a+j));r=0;break;}
if(b>=8){b=0;break;}}}}

Eek! Look at all that terrible code. Anyway, main() implements a well-known algorithm. Can you figure out what it is?

It’s because the % operation is implementation defined over negative integers in C. It was originally written by nomis, pippin, and me for a GIMP patch many moons ago, but we decided not to put the patch in. As this code took a while to arrive at, here it is for your pleasure and so that we may never have to rewrite it.

#define REMAINDER(dividend, divisor)
                   (((dividend) < 0) ?
                    (divisor) - 1 - ((-(dividend) - 1) % (divisor)) :
                    (dividend) % (divisor))

Update: The macro assumes a positive divisor. Our divisor was always a constant positive integer literal.

Morten Welinder found an underflow situation in the code above when INT_MIN is used as the dividend, which may fall in yet another undefined part of the C specification. Basically in the sub-expression (-(dividend) - 1), -(dividend) == (dividend) when dividend == INT_MIN. And INT_MIN - 1 will underflow (and wrap-around to INT_MAX in the case of most microprocessors’ two’s complement registers), and this behaviour is not defined in C. Although it’ll work fine on most general purpose CPUs, because this is undocumented, there may be issues if gcc tries to reduce it at -O2 if both dividend and divisor are constants. More correct code with Morten’s patch is:

#define REMAINDER(dividend, divisor)
                   (((dividend) < 0) ?
                    (divisor) - 1 - ((-((dividend) + 1)) % (divisor)) :
                    (dividend) % (divisor))

It won’t overflow over INT_MAX in this case, as dividend is less than 0 when that sub-expression is used. So now, we have 4 authors.