______________________________________________________________________

  6   Statements                                             [stmt.stmt]

  ______________________________________________________________________

1 Except as indicated, statements are executed in sequence.
  statement:
          labeled-statement
          expression-statement
          compound-statement
          selection-statement
          iteration-statement
          jump-statement
          declaration-statement
          try-block

  6.1  Labeled statement                                    [stmt.label]

1 A statement can be labeled.
  labeled-statement:
          identifier : statement
          case constant-expression : statement
          default : statement
  An identifier label declares the identifier.  The only use of an iden-
  tifier  label is as the target of a goto.  The scope of a label is the
  function in which it appears.  Labels shall not be redeclared within a
  function.   A label can be used in a goto statement before its defini-
  tion.  Labels have their own name space  and  do  not  interfere  with
  other identifiers.

2 Case  labels and default labels shall occur only in switch statements.

  6.2  Expression statement                                  [stmt.expr]

1 Expression statements have the form
  expression-statement:
          expressionopt ;
  The expression is evaluated and its value is discarded.   The  lvalue-
  to-rvalue  (_conv.lval_),  array-to-pointer  (_conv.array_), and func-
  tion-to-pointer (_conv.func_) standard conversions are not applied  to
  the  expression.   All  side  effects from an expression statement are
  completed before the next statement is executed.  An expression state-
  ment  with  the expression missing is called a null statement.  [Note:
  Most statements  are  expression  statements--usually  assignments  or
  function  calls.   A  null  statement  is useful to carry a label just
  before the } of a compound statement and to supply a null body  to  an
  iteration statement such as a while statement (_stmt.while_).  ]

  6.3  Compound statement or block                          [stmt.block]

1 So that several statements can be used where one is expected, the com-
  pound statement (also, and equivalently, called "block") is  provided.
  compound-statement:
           { statement-seqopt }
  statement-seq:
          statement
          statement-seq statement
  A  compound statement defines a local scope (_basic.scope_).  [Note: a
  declaration is a statement (_stmt.dcl_).  ]

  6.4  Selection statements                                [stmt.select]

1 Selection statements choose one of several flows of control.
  selection-statement:
          if ( condition ) statement
          if ( condition ) statement else statement
          switch ( condition ) statement
  condition:
          expression
          type-specifier-seq declarator = assignment-expression
  In clause _stmt.stmt_, the term substatement refers to  the  contained
  statement  or statements that appear in the syntax notation.  The sub-
  statement in a selection-statement (both substatements,  in  the  else
  form   of   the   if  statement)  implicitly  defines  a  local  scope
  (_basic.scope_).  If the substatement in a  selection-statement  is  a
  single  statement  and  not  a  compound-statement, it is as if it was
  rewritten to be a compound-statement containing the original substate-
  ment.  [Example:
  if (x)
      int i;
  can be equivalently rewritten as
  if (x) {
      int i;
  }
  Thus after the if statement, i is no longer in scope.  ]

2 The rules for conditions apply both to selection-statements and to the
  for and while statements  (_stmt.iter_).   The  declarator  shall  not
  specify a function or an array.  The type-specifier-seq shall not con-
  tain typedef and shall not declare a new class or enumeration.

3 A name introduced by a declaration in a condition  (either  introduced
  by  the  type-specifier-seq  or the declarator of the condition) is in
  scope from its point of declaration until the end of the substatements
  controlled by the condition.  If the name is re-declared in the outer-
  most block of a substatement controlled by the condition, the declara-
  tion that re-declares the name is ill-formed.  [Example:

  if (int x = f()) {
          int x;                  // ill-formed, redeclaration of x
  }
  else {
          int x;                  // ill-formed, redeclaration of x
  }
   --end example]

4 The  value  of  a  condition  that  is an initialized declaration in a
  statement other than a switch statement is the value of  the  declared
  variable  implicitly  converted  to  type bool.  If that conversion is
  ill-formed, the program is ill-formed.  The value of a condition  that
  is  an  initialized  declaration in a switch statement is the value of
  the declared variable if it has integral or enumeration  type,  or  of
  that  variable  implicitly  converted  to integral or enumeration type
  otherwise.  The value of a condition that  is  an  expression  is  the
  value  of  the expression, implicitly converted to bool for statements
  other than switch; if that conversion is ill-formed,  the  program  is
  ill-formed.   The value of the condition will be referred to as simply
  "the condition" where the usage is unambiguous.

5 If a condition can be syntactically resolved as either  an  expression
  or  the  declaration  of a local name, it is interpreted as a declara-
  tion.

  6.4.1  The if statement                                      [stmt.if]

1 If the condition (_stmt.select_) yields true the first substatement is
  executed.   If the else part of the selection statement is present and
  the condition yields false, the second substatement is  executed.   In
  the second form of if statement (the one including else), if the first
  substatement is also an if statement  then  that  inner  if  statement
  shall contain an else part.1)

  6.4.2  The switch statement                              [stmt.switch]

1 The switch statement causes control to be transferred to one  of  sev-
  eral statements depending on the value of a condition.

2 The  condition  shall  be  of integral type, enumeration type, or of a
  class type for which a single conversion function to integral or  enu-
  meration  type  exists  (_class.conv_).   If the condition is of class
  type, the condition is converted by calling that conversion  function,
  and the result of the conversion is used in place of the original con-
  dition for the remainder of this  section.   Integral  promotions  are
  performed.   Any  statement within the switch statement can be labeled
  with one or more case labels as follows:
          case constant-expression :
  where the constant-expression shall be  an  integral  constant-expres-
  sion.   The  integral constant-expression (_expr.const_) is implicitly
  _________________________
  1)  In  other  words, the else is associated with the nearest un-elsed
  if.

  converted to the promoted type of the switch condition.  No two of the
  case constants in the same switch shall have the same value after con-
  version to the promoted type of the switch condition.

3 There shall be at most one label of the form
  default :
  within a switch statement.

4 Switch statements can be nested; a case or default label is associated
  with the smallest switch enclosing it.

5 When  the switch statement is executed, its condition is evaluated and
  compared with each case constant.  If one of  the  case  constants  is
  equal  to  the value of the condition, control is passed to the state-
  ment following the matched case label.  If no  case  constant  matches
  the  condition, and if there is a default label, control passes to the
  statement labeled by the default label.  If no  case  matches  and  if
  there  is no default then none of the statements in the switch is exe-
  cuted.

6 case and default labels in themselves do not alter the  flow  of  con-
  trol,  which  continues  unimpeded across such labels.  To exit from a
  switch, see break, _stmt.break_.   [Note:  usually,  the  substatement
  that  is  the  subject  of  a  switch is compound and case and default
  labels appear on the top-level statements contained within  the  (com-
  pound)  substatement,  but  this  is  not  required.  Declarations can
  appear in the substatement of a switch-statement.  ]

  6.5  Iteration statements                                  [stmt.iter]

1 Iteration statements specify looping.
  iteration-statement:
          while ( condition ) statement
          do statement  while ( expression ) ;
          for ( for-init-statement conditionopt ; expressionopt ) statement
  for-init-statement:
          expression-statement
          simple-declaration
  [Note: a for-init-statement ends with a semicolon.  ]

2 The substatement in an iteration-statement implicitly defines a  local
  scope  (_basic.scope_)  which  is entered and exited each time through
  the loop.

3 If the substatement in an iteration-statement is  a  single  statement
  and  not  a  compound-statement,  it is as if it was rewritten to be a
  compound-statement containing the original statement.  [Example:
  while (--x >= 0)
      int i;
  can be equivalently rewritten as
  while (--x >= 0) {
      int i;
  }
  Thus after the while statement, i is no longer in scope.  ]

4 [Note: The requirements on  conditions  in  iteration  statements  are
  described in _stmt.select_.   --end note]

  6.5.1  The while statement                                [stmt.while]

1 In  the  while statement the substatement is executed repeatedly until
  the value of the condition (_stmt.select_) becomes  false.   The  test
  takes place before each execution of the substatement.

2 When the condition of a while statement is a declaration, the scope of
  the variable that is declared extends from its  point  of  declaration
  (_basic.scope.pdecl_)  to  the  end  of  the while statement.  A while
  statement of the form
  while (T t = x) statement
  is equivalent to
  label:
  {                               // start of condition scope
      T t = x;
      if (t) {
          statement
          goto label;
      }
  }                               // end of condition scope
  The object created in a condition is destroyed and created  with  each
  iteration of the loop.  [Example:
  struct A {
      int val;
      A(int i) : val(i) { }
      ~A() { }
      operator bool() { return val != 0; }
  };
  int i = 1;
  while (A a = i) {
      //...
      i = 0;
  }
  In  the  while-loop,  the  constructor  and destructor are each called
  twice, once for the condition that succeeds and once for the condition
  that fails.  ]

  6.5.2  The do  statement                                     [stmt.do]

1 The  expression is implicitly converted to bool; if that is not possi-
  ble, the program is ill-formed.

2 In the do statement the substatement is executed repeatedly until  the
  value  of  the  expression  becomes false.  The test takes place after
  each execution of the statement.

  6.5.3  The for statement                                    [stmt.for]

1 The for statement
  for ( for-init-statement conditionopt ; expressionopt ) statement
  is equivalent to

  {
          for-init-statement
          while ( condition ) {
                  statement
                  expression ;
          }
  }
  except that names declared in the for-init-statement are in  the  same
  declarative-region as those declared in the condition, and except that
  a continue in statement (not enclosed in another iteration  statement)
  will  execute  expression before re-evaluating condition.  [Note: Thus
  the first statement specifies initialization for the loop; the  condi-
  tion  (_stmt.select_)  specifies  a  test, made before each iteration,
  such that the loop is exited when the  condition  becomes  false;  the
  expression often specifies incrementing that is done after each itera-
  tion.  ]

2 Either or both of the condition and the expression can be omitted.   A
  missing  condition  makes  the  implied  while  clause  equivalent  to
  while(true).

3 If the for-init-statement is a declaration, the scope of  the  name(s)
  declared extends to the end of the for-statement.  [Example:
  int i = 42;
  int a[10];

  for (int i = 0; i < 10; i++)
          a[i] = i;

  int j = i;                      // j = 42
   --end example]

  6.6  Jump statements                                       [stmt.jump]

1 Jump statements unconditionally transfer control.
  jump-statement:
          break ;
          continue ;
          return expressionopt ;
          goto identifier ;

2 On   exit   from   a   scope   (however   accomplished),   destructors
  (_class.dtor_) are called for all constructed objects  with  automatic
  storage  duration  (_basic.stc.auto_)  (named  objects or temporaries)
  that are declared in that scope, in the reverse order of their  decla-
  ration.   Transfer out of a loop, out of a block, or back past an ini-
  tialized  variable  with  automatic  storage  duration  involves   the
  destruction  of  variables with automatic storage duration that are in
  scope at the point transferred from but not at the  point  transferred
  to.   (See _stmt.dcl_ for transfers into blocks).  [Note: However, the
  program can be terminated  (by  calling  exit()  or  abort()(_lib.sup-
  port.start.term_),  for example) without destroying class objects with
  automatic storage duration.  ]

  6.6.1  The break statement                                [stmt.break]

1 The break statement shall occur only in an  iteration-statement  or  a
  switch  statement  and  causes  termination  of the smallest enclosing
  iteration-statement or switch statement; control passes to the  state-
  ment following the terminated statement, if any.

  6.6.2  The continue statement                              [stmt.cont]

1 The  continue statement shall occur only in an iteration-statement and
  causes control to pass to the loop-continuation portion of the  small-
  est  enclosing  iteration-statement,  that is, to the end of the loop.
  More precisely, in each of the statements
      while (foo) {       do {                for (;;) {
       {                   {                   {
        // ...              // ...              // ...
       }                   }                   }
      contin: ;           contin: ;           contin: ;
      }                   } while (foo);      }
  a continue not contained in an enclosed iteration statement is equiva-
  lent to goto contin.

  6.6.3  The return statement                              [stmt.return]

1 A function returns to its caller by the return statement.

2 A return statement without an expression can be used only in functions
  that do not return a value, that is, a function with the  return  type
  void, a constructor (_class.ctor_), or a destructor (_class.dtor_).  A
  return statement with an expression of non-void type can be used  only
  in  functions  returning  a  value;  the  value  of  the expression is
  returned to the caller of the function.  The expression is  implicitly
  converted  to  the return type of the function in which it appears.  A
  return statement can involve the construction and copy of a  temporary
  object  (_class.temporary_).   Flowing  off  the  end of a function is
  equivalent to a return with no value; this results in undefined behav-
  ior in a value-returning function.

3 A  return  statement  with an expression of type "cv void" can be used
  only in functions with a return type of cv  void;  the  expression  is
  evaluated just before the function returns to its caller.

  6.6.4  The goto statement                                  [stmt.goto]

1 The  goto statement unconditionally transfers control to the statement
  labeled  by  the  identifier.   The  identifier  shall  be   a   label
  (_stmt.label_) located in the current function.

  6.7  Declaration statement                                  [stmt.dcl]

1 A  declaration statement introduces one or more new identifiers into a
  block; it has the form
  declaration-statement:
          block-declaration

  If an identifier introduced by a declaration was  previously  declared
  in  an  outer block, the outer declaration is hidden for the remainder
  of the block, after which it resumes its force.

2 Variables with automatic storage duration (_basic.stc.auto_) are  ini-
  tialized each time their declaration-statement is executed.  Variables
  with automatic storage duration declared in the block are destroyed on
  exit from the block (_stmt.jump_).

3 It  is  possible  to  transfer  into  a  block,  but not in a way that
  bypasses  declarations  with  initialization.   A program that jumps2)
  from a point where a local variable with automatic storage duration is
  not  in scope to a point where it is in scope is ill-formed unless the
  variable has POD type (_basic.types_) and is declared without an  ini-
  tializer (_dcl.init_).  [Example:
  void f()
  {
      // ...
      goto lx;                    // ill-formed: jump into scope of a
      // ...
  ly:
      X a = 1;
      // ...
  lx:
      goto ly;                    // OK, jump implies destructor
                                  // call for a followed by construction
                                  // again immediately following label ly
  }
   --end example]

4 The  zero-initialization (_dcl.init_) of all local objects with static
  storage duration (_basic.stc.static_) is performed  before  any  other
  initialization   takes   place.    A   local   object   of   POD  type
  (_basic.types_) with static storage  duration  initialized  with  con-
  stant-expressions  is  initialized  before its block is first entered.
  An implementation is permitted  to  perform  early  initialization  of
  other local objects with static storage duration under the same condi-
  tions that an implementation is permitted to statically initialize  an
  object    with    static   storage   duration   in   namespace   scope
  (_basic.start.init_).  Otherwise such an  object  is  initialized  the
  first  time  control passes through its declaration; such an object is
  considered initialized upon the completion of its initialization.   If
  the  initialization exits by throwing an exception, the initialization
  is not complete, so it will be  tried  again  the  next  time  control
  enters  the declaration.  If control re-enters the declaration (recur-
  sively) while the object is being initialized, the behavior  is  unde-
  fined.  [Example:

  _________________________
  2) The transfer from the condition of a switch statement to a case la-
  bel is considered a jump in this respect.

  int foo(int i)
  {
      static int s = foo(2*i);    // recursive call - undefined
      return i+1;
  }
   --end example]

5 The destructor for a local object with static storage duration will be
  executed  if  and  only  if  the  variable  was  constructed.   [Note:
  _basic.start.term_  describes  the  order  in which local objects with
  static storage duration are destroyed.  ]

  6.8  Ambiguity resolution                                 [stmt.ambig]

1 There is an ambiguity in the grammar  involving  expression-statements
  and   declarations:  An  expression-statement  with  a  function-style
  explicit type conversion (_expr.type.conv_) as its leftmost subexpres-
  sion  can  be  indistinguishable  from  a  declaration where the first
  declarator starts with a (.  In those cases the statement is a  decla-
  ration.   [Note: To disambiguate, the whole statement might have to be
  examined to determine if it is an expression-statement or  a  declara-
  tion.   This  disambiguates  many examples.  [Example: assuming T is a
  simple-type-specifier (_dcl.type_),
          T(a)->m = 7;            // expression-statement
          T(a)++;                 // expression-statement
          T(a,5)<<c;              // expression-statement
          T(*d)(int);             // declaration
          T(e)[5];                // declaration
          T(f) = { 1, 2 };        // declaration
          T(*g)(double(3));       // declaration
  In the last example above, g, which is a pointer to T, is  initialized
  to  double(3).  This is of course ill-formed for semantic reasons, but
  that does not affect the syntactic analysis.   --end example]

2 The remaining cases are declarations.  [Example:
          class T {
                  // ...
          public:
                  T();
                  T(int);
                  T(int, int);
          };
          T(a);                   // declaration
          T(*b)();                // declaration
          T(c)=7;                 // declaration
          T(d),e,f=3;             // declaration
          extern int h;
          T(g)(h,2);              // declaration
   --end example]  --end note]

3 The disambiguation is purely syntactic; that is, the  meaning  of  the
  names  occurring  in  such  a statement, beyond whether they are type-
  names or not, is not generally used in or changed by  the  disambigua-
  tion.  Class templates are instantiated as necessary to determine if a

  qualified name is a type-name.  Disambiguation precedes parsing, and a
  statement disambiguated as a declaration may be an ill-formed declara-
  tion.  If, during parsing, a name in a  template  parameter  is  bound
  differently  than  it would be bound during a trial parse, the program
  is ill-formed.  No diagnostic is required.  [Note: This can occur only
  when the name is declared earlier in the declaration.  ] [Example:
  struct T1 {
          T1 operator()(int x) { return T1(x); }
          int operator=(int x) { return x; }
          T1(int) { }
  };
  struct T2 { T2(int){ } };
  int a, (*(*b)(T2))(int), c, d;
  void f() {
          // disambiguation requires this to be parsed
          // as a declaration
          T1(a) = 3,
          T2(4),                  // T2 will be declared as
          (*(*b)(T2(c)))(int(d)); // a variable of type T1
                                  // but this will not allow
                                  // the last part of the
                                  // declaration to parse
                                  // properly since it depends
                                  // on T2 being a type-name
  }
   --end example]