A generalization of the Fortran 95/90 WHERE statement and
  construct.  It allows more general array shapes to be assigned,
  especially in construct form.  Statement format:

    FORALL (triplet-spec [,triplet-spec]...[,mask-expr]) assign-stmt

  Construct format:

    [name: ] FORALL (triplet-spec [,triplet-spec]...[,mask-expr])
    forall-body-stmt
    [forall-body-stmt]...
    END FORALL [name]

    name          Is the name of the FORALL construct.

    triplet-spec  Is a triplet specification with the following form:

      subscript-name = subscript-1 : subscript-2 [:stride]

      The "subscript-name" must be a scalar of type integer.
      It is valid only within the scope of the FORALL; its
      value is undefined on completion of the FORALL.

      The "subscript"s and "stride" cannot contain a reference
      to any "subscript-name" in "triplet-spec".

      The "stride" cannot be zero.  If it is omitted, the default
      value is 1.

      Evaluation of an expression in a triplet specification must
      not affect the result of evaluating any other expression in
      another triplet specification.

    mask-expr  Is a logical array expression (called the mask
               expression). If it is omitted, the value .TRUE.
               is assumed. The mask expression can reference the
               subscript name in "triplet-spec".

    assign-stmt  Is an assignment statement or a pointer assignment
                 statement. The variable being assigned to must be
                 an array element or array section and must reference
                 all subscript names included in all "triplet-spec"s.

    forall-body-stmt  Is one of the following:
                      o An "assign-stmt"
                      o A WHERE statement or construct
                        The WHERE statement or construct uses a mask
                        to make array assignments.
                      o A FORALL statement or construct

  If a construct name is specified in the FORALL statement, the same
  name must appear in the corresponding END FORALL statement.

  A FORALL statement is executed by first evaluating all bounds and
  stride expressions in the triplet specifications, giving a set of
  values for each subscript name.  The FORALL assignment statement is
  executed for all combinations of subscript name values for which
  the mask expression is true.

  The FORALL assignment statement is executed as if all expressions
  (on both sides of the assignment) are completely evaluated before
  any part of the left side is changed.  Valid values are assigned to
  corresponding elements of the array being assigned to.  No element
  of an array can be assigned a value more than once.

  A FORALL construct is executed as if it were multiple FORALL
  statements, with the same triplet specifications and mask
  expressions.  Each statement in the FORALL body is executed
  completely before execution begins on the next FORALL body
  statement.

  Any procedure referenced in the mask expression or FORALL
  assignment statement must be pure.

  Pure functions can be used in the mask expression or called
  directly in a FORALL statement.  Pure subroutines cannot be called
  directly in a FORALL statement, but can be called from other pure
  procedures.

  EXAMPLES:

  Consider the following:

    FORALL(I = 1:N, J = 1:N, A(I, J) .NE. 0.0) B(I, J) = 1.0 / A(I, J)

  This statement takes the reciprocal of each nonzero element of
  array A(1:N, 1:N) and assigns it to the corresponding element of
  array B.  Elements of A that are zero do not have their reciprocal
  taken, and no assignments are made to corresponding elements of B.

  Every array assignment statement and WHERE statement can be written
  as a FORALL statement, but some FORALL statements cannot be written
  using just array syntax.  For example, the preceding FORALL
  statement is equivalent to the following:

    WHERE(A /= 0.0) B = 1.0 / A

  It is also equivalent to:

    FORALL (I = 1:N, J = 1:N)
      WHERE(A(I, J) .NE. 0.0) B(I, J) = 1.0/A(I, J)
    END FORALL

  However, the following FORALL example cannot be written using just
  array syntax:

     FORALL(I = 1:N, J = 1:N) H(I, J) = 1.0/REAL(I + J - 1)

  This statement sets array element H(I, J) to the value 1.0/REAL(I +
  J - 1) for values of I and J between 1 and N.

  Consider the following:

    TYPE MONARCH
      INTEGER, POINTER :: P
    END TYPE MONARCH

    TYPE(MONARCH), DIMENSION(8)   :: PATTERN
    INTEGER, DIMENSION(8), TARGET :: OBJECT
    FORALL(J=1:8)  PATTERN(J)%P => OBJECT(1+IEOR(J-1,2))

  This FORALL statement causes elements 1 through 8 of array PATTERN
  to point to elements 3, 4, 1, 2, 7, 8, 5, and 6, respectively, of
  OBJECT.  IEOR can be referenced here because it is pure.

  The following example shows a FORALL construct:

    FORALL(I = 3:N + 1, J = 3:N + 1)
      C(I, J) = C(I, J + 2) + C(I, J - 2) + C(I + 2, J) + C(I - 2, J)
      D(I, J) = C(I, J)
    END FORALL

  The assignment to array D uses the values of C computed in the
  first statement in the construct, not the values before the
  construct began execution.

  FORALL is a language feature of Fortran 95.