Why enclose blocks of C code in curly braces?

I am looking at some C code, and have noticed it is full of these curly braces surrounding blocks of code without any sort of control structure. Take a look-see:

//do some stuff . . . fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC); { //a block! why not? char *tmp_argv[3]; tmp_argv[0] = argv[0]; tmp_argv[1] = str; tmp_argv[2] = prefix; t = clock(); fprintf(stderr, "[bwa_index] Convert nucleotide PAC to color PAC... "); bwa_pac2cspac(3, tmp_argv); fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC); }

Why would you insert blocks like this in the code? It is chock full of 'em. Is there some kind of performance benefit? Some mystical C thing? Why???

edit: This code if from http://bio-bwa.sourceforge.net">BWA</a>;, a bioinformatics program that aligns small sequences to large reference ones using the http://en.wikipedia.org/wiki/Burrows%E2%80%93Wheeler_transform">Burrows-Wheeler transform, in case any of you were wondering. This code example isn't particularly relevant to the functionality of the application.

Legacy code needed { } in order to do declarations at all

In C89, you couldn't just do int i; anywhere; declarations were only valid at the beginning of blocks.

So:

a = 1;
int i; /* error */
i = 2;

...wasn't valid, but

a = 1
if (e) {
  int i;

...was fine, as was a plain block.

The resulting style continued even after declarations became valid (C99) block-item(s), partly by inertia, partly for backwards portability, and also because it makes sense to establish a scope for new declarations.

To scope variables. E.g. the variable tmp_argv will only be valid between the braces.

Another use case for this I've recently discovered is when you have open/close semantics and you want to clearly mark the 'inner' code:

f = fopen('file');
{
    // do stuff
}
fclose(f);

This works well to remind you to close/free objects and a makes the code somewhat cleaner.

A block is a scope that determines the lifetime of variables, as well as their visibility to the compiler. So variables that get created within a block go away when control exits the block.

It can be very handy when those variables are instances of classes with constructors and destructors.

However, in your example there is not much advantage.

It is creating a scope. Stack objects are destroyed when they go out of scope. It looks like it is doing some sort of typing, which would mean each block is something that they wanted to time. However, I don't see any scoped timer objects, so, yeah, makes no sense.

The variables that you declare inside the block are local to that block. This way you may be able to redefine tmp_argv in some other place of your code (below) without conflicting with this piece of code.

Is that all of it? Maybe the programmer is using tmp_argv somewhere else in the code. I can't think of any other reason since the tmp_argv between the { and } is separate from any outside the braces.

I sometimes use blocks in these cases:

• To localize variables
• Or to easier to read ...

Hmm - I'm maybe off the chart here but I think local variable define inside such block will not be valid outside of the block