code: def fix_switch_cases(switch_node):
      """The 'case' statements in a 'switch' come out of parsing with one
      child node, so subsequent statements are just tucked to the parent
      Compound. Additionally, consecutive (fall-through) case statements
      come out messy. This is a peculiarity of the C grammar. The following:
  
          switch (myvar) {
              case 10:
                  k = 10;
                  p = k + 1;
                  return 10;
              case 20:
              case 30:
                  return 20;
              default:
                  break;
          }
  
      Creates this tree (pseudo-dump):
  
          Switch
              ID: myvar
              Compound:
                  Case 10:
                      k = 10
                  p = k + 1
                  return 10
                  Case 20:
                      Case 30:
                          return 20
                  Default:
                      break
  
      The goal of this transform is to fix this mess, turning it into the
      following:
  
          Switch
              ID: myvar
              Compound:
                  Case 10:
                      k = 10
                      p = k + 1
                      return 10
                  Case 20:
                  Case 30:
                      return 20
                  Default:
                      break
  
      A fixed AST node is returned. The argument may be modified.
      """
      assert isinstance(switch_node, c_ast.Switch)
      if not isinstance(switch_node.stmt, c_ast.Compound):
          return switch_node
  
      # The new Compound child for the Switch, which will collect children in the
      # correct order
      new_compound = c_ast.Compound([], switch_node.stmt.coord)
  
      # The last Case/Default node
      last_case = None
  
      # Goes over the children of the Compound below the Switch, adding them
      # either directly below new_compound or below the last Case as appropriate
      # (for `switch(cond) {}`, block_items would have been None)
      for child in switch_node.stmt.block_items or []:
          if isinstance(child, (c_ast.Case, c_ast.Default)):
              # If it's a Case/Default:
              # 1. Add it to the Compound and mark as "last case"
              # 2. If its immediate child is also a Case or Default, promote it
              #    to a sibling.
              new_compound.block_items.append(child)
              _extract_nested_case(child, new_compound.block_items)
              last_case = new_compound.block_items[-1]
          else:
              # Other statements are added as children to the last case, if it
              # exists.
              if last_case is None:
                  new_compound.block_items.append(child)
              else:
                  last_case.stmts.append(child)
  
      switch_node.stmt = new_compound
      return switch_node
  
imports: from .None import c_ast
label_desc: Use image node_id 1 for calling a global function with example usage: fix_switch_cases(switch_node) and returns: switch_node, switch_node