Jim's Depository

I find myself missing a flow of control construct in C. Let’s say I want to locate a value which might come from a number of sources then do something with it.

if ( code == 36) value = 99; else { // a bunch of code to see if it is in the cache if ( code_in_cache(code)) value = code_from_cache(code); else { // notice how each place I have to look is  //accumulating nesting?
… }
}

If I were willing to split the code into a separate function I could just use return e.g.

int gratuitous_function( int code) { if ( code == 36) return 99;
// a bunch of code to see if it is the cache
if ( code_in_cache(code)) return code_from_cache(code);
// notice how I am not accumulating nesting?
…
}

That is better, but I don’t like breaking the linear flow of the program and it is likely that the function will require access to many of my local variables making a complicated interface. Worse, I may be setting several values and that gets ugly.

I generally try to cope like this…

do {

if ( code == 36) { value = 99; break; }
// a bunch of code to see if it is in the cache
if ( code_in_cache(code)) {  value = code_from_cache(code);  break;  } // notice how I am not accumulating nesting? … } while(0);

That works fine until I locate the value inside a for loop, then the break will take it out of the for loop.

I think what I really want is a named block…

block foo {

if ( code == 36) { value = 99; break foo; }
// a bunch of code to see if it is in the cache
if ( code_in_cache(code)) {  value = code_from_cache(code);  break foo;  } // notice how I am not accumulating nesting? … }

I guess I could always be a barbarian just use a goto and a label.