Why it is valid to intertwine switch/for/if statements in C/C++?

I'm reading boost/asio/coroutine.hpp and cannot understand the implementation of BOOST_ASIO_CORO_REENTER and BOOST_ASIO_CORO_YIELD. The expanded form of

reenter (this) {
  yield ..
  yield ..
}

seems to be intertwined switch/if/for statements. I'm wondering how come this is valid C code? I wrote something similar (shown below) and found it compiles using gcc.

int main() {
  int a = 1;
  switch (a)
  case 0: if (1) a = 2;
  else case 1: for (;;) {
    case 3:
      break;
  }

  return 0;
}

The reason is because switch statements aren't structured control flow statements. Instead, they should be considered as syntactic sugar for static dispatch. Dispatch means that the control flow is redirected and static means that the compiler knows where it is redirected to.

So your code

int a = 1;
switch (a)
case 0: if (1) a = 2;
else case 1: for (;;) {
  case 3:
    break;
}
return 0;

would be compiled into something roughly equivalent of

int a = 1;
void *dest = dispatch(a, { case0_addr, case1_addr, case3_addr });
goto *dest;
case0_addr:
if (1) { 
  a = 2;
} else {
case1_addr:
  for (;;) {
    case3_addr:
    goto case_end;
  }
}
case_end:
return 0;

where dispatch is a function the compiler runs for emitting the machine code required for the static dispatch. Since all dispatch values are constants and all dispatch targets are known by the compiler, it can generate very efficient machine code.

As for why it is legal, I guess the reason is because there's no particular reason for it to be illegal. As shown, case statements are just goto labels so they can be placed wherever.

Syntactically, the body of a switch is just a statement (usually, but not necessarily a compound statement)

6.8:

statement:
			   labeled-statement
			   compound-statement
			   expression-statement
			   selection-statement
			   iteration-statement
			   jump-statement

which may be labeled
6.8.1:

labeled-statement:
				identifier : statement
				case constant-expression : statement
				default : statement

Example:

switch(1) one: case 1: dothis();

If it is a compound statement, then each substatement recursively may also be labeled. Example:

switch(x) {
	if(1) one: case 1: dothis();
	else case 0: orthis();  /*fallthru*/
	three: case 3: three();
}

The syntax treats case/default-labels and regular labels the same, only the semantic check verifies that case/default-labels be inside a switch.

Implementation-wise, everything compiles into (flat) assembly.

E.g.

if(test) YesBranch; else ElseBranch;

is flattened into (pseudo-assembly)

IF_NOT_THEN_GOTO(test, PAST_YES_BRANCH)
YesBranch
goto PAST_NO_BRANCH;
NoBranch
PAST_NO_BRANCH:;

and there's no reason why anything in such flat code couldn't be labeled.

case/default labels are also just like regular labels except they're also used in (most usually) a computed jump.