Is there any better implementation for this switch case construct?

Question

I'm working on an embedded system where a register hast to be accessed and after that to be incremented to achieve the result I'm looking for, since the machine is notifying and configured to react on my access and changing or not changing the flag. So the switch's argument has to be kept as it is, since it would otherwise change the behaving of the embedded system.

But there may occur a situation where I don't want to get any of the cases get invoked. But I still need to acces and increment the argument of the switch.

(More indepth I'm converting a sequence of analog values to digital values conversions step by step. The index is used to stay synchronized with the current conversion and relating it with the corresponding case to handle the figure correct. There may occur a state in which the index desynchronisizes to the current conversion so the sequence of conversions must be run through without any of the cases getting invoked (to prevent setting wrong data) untill the sequence is finished and the resynchroinisation can get performed)

The way I'm currently doing this is this:

switch (RunIndex++)/*RunIndex may only be accessed one time per execution
of this construct and has to be incremented in the same step. thats given.*/
{
   if (RunIndexSyncedWithADCensured == false)
   {
     break;
   }
   case 0:
     Case0RelatedData = SomeOperationsForCase0(RawData);
     break;
   case 1:
     Case1RelatedData = SomeOperationsForCase1(RawData);
     break;
   case 2:
     Case2RelatedData = SomeOperationsForCase2(RawData);
     break;
   default:
     RunIndex = 0;
     break;
}

This construct does the job but it looks like it is a bit controversial and I don't feel well by considering about committing this into productinal code.

So is there a better looking way to achieve the same, without the need of additional variables or assignements?

note:

Also it may be relevant, that this is in the first part of a interupt function consisting of 2 parts. The first part handles what has to happen if() a conversion is finished. The second part, what has additional to be done if() this conversion also ended the sequence. So it is no option to simply return from the function without getting into the second part. and there is currently no loop structure where an if(...)break; may break out. (What is also the reason why I'm putting the if inside the switch scope, as it is at least by standard a valid way to break out.)

Answer 1

Since you are using adjacent index numbers, you could make an array of function pointers to replace the switch. That's what the optimizer will turn the switch into anyhow. So instead of your obscure switch, you get this:

if (RunIndexSyncedWithADCensured)
{
  SomeOperationsForCase[RunIndex](RawData);
}

RunIndex++;
if (RunIndex > MAX)
{
  RunIndex = 0;
}

---

Completely unrelated to the switch statement design: in case RunIndex is a sensitive volatile variable such as some hardware register, then you shouldn't use it directly in any form of computations. Make a copy of it:

volatile int RunIndex; 
...

int index = RunIndex; // read from RunIndex

if (RunIndexSyncedWithADCensured)
{
  SomeOperationsForCase[index](RawData);
}

index++;
if (index > MAX)
{
  index  = 0;
}

RunIndex = index; // write to RunIndex

This is standard practice for all such volatile variables.

Answer 2

Firstly, the if() inside switch() will never be executed.
Consider the below code snippet:

#include <stdio.h>

int main(int argc, char *argv[])
{
    int i = 2;

    switch(i) {
        if (i == 2) {
            printf("I M HERE\n");
        }
        case 1:
            printf("1\n");
        break;
        case 2:
            printf("2\n");
        break;
        default:
            printf("default\n");
        break;
    }
    return 0;
}

For your code: you expect the string I M HERE to be printed. But that is not the case.
The output for the above code snippet is:

2

No statements before case/default(switch constructs): is executed inside switch

Now to answer for

I don't want to get any of the cases get invoked. But I still need to acces and increment the argument of the switch

Just move the if() outside to the switch().

if (RunIndexSyncedWithADCensured) {
    switch (RunIndex++) {
        case 0:
            Case0RelatedData = SomeOperationsForCase0(RawData);
            break;
            /* Other cases here */
        default:
           RunIndex = 0;
           break;
    }
} else
    RunIndex++;

Answer 3

Why not save the value first and then increment it and use the saved value in the switch? By the way this also includes two accesses, first to read the value from RunIndex and the second to increment it.

int runIndex = (RunIndex++);
if (RunIndexSyncedWithADCensured )
{
    switch (runIndex)/*RunIndex may only be accessed one time per execution
    of this construct and has to be incremented in the same step. thats given.*/
    {
        case 0:
            Case0RelatedData = SomeOperationsForCase0(RawData);
            break;
        case 1:
            Case1RelatedData = SomeOperationsForCase1(RawData);
            break;
        case 2:
           Case2RelatedData = SomeOperationsForCase2(RawData);
           break;
        default:
           RunIndex = 0;
           break;
    }
}