Specification

 A specification expression is a restricted expression that is of
 type integer and has a scalar value.  This type of expression
 appears only in the declaration of array bounds and character
 lengths.

 In a restricted expression, each operation is intrinsic and each
 operand is one of the following:

  o  A constant or subobject of a constant

  o  A variable that is one of the following:

         - A dummy argument that does not have the OPTIONAL or
             INTENT (OUT) attribute (or the subobject of such 
             a variable)
         - In a common block (or the subobject of such a variable)
         - Made accessible by use or host association (or the 
             subobject of such a variable)

  o  A structure constructor whose components are restricted
     expressions

  o  An implied-do variable within an array constructor where the
     bounds and strides of the corresponding implied-do are
     initialization expressions

  o  A reference to one of the following inquiry functions:

         BIT_SIZE               NWORKERS
         DIGITS                 PRECISION
         EPSILON                PROCESSORS_SHAPE
         HUGE                   RADIX
         ILEN                   RANGE
         KIND                   SHAPE
         LBOUND                 SIZE
         LEN                    SIZEOF
         MAXEXPONENT            TINY
         MINEXPONENT            UBOUND
         NUMBER_OF_PROCESSORS

     Each function argument must be one of the following:

         - A restricted expression
         - A variable whose properties inquired about are not
           dependent on the upper bound of the last dimension 
           of an assumed-size array, are not defined by an 
           expression that is a restricted expression, or are 
           not definable by an ALLOCATE or pointer assignment 
           statement.

  o  A reference to any other intrinsic function where each argument
     is a restricted expression.

  o  A reference to a specification function (see below) where each
     argument is a restricted expression

  o  An array constructor where each element, and bounds and strides
     of each implied-do are expressions whose primaries are
     restricted expressions

  o  Another restricted expression enclosed in parentheses


 Each subscript, section subscript, and substring starting and
 ending point must be a restricted expression.

 Specification functions can be used in specification expressions to
 indicate the attributes of data objects.  A specification function
 is a pure function.  It cannot have a dummy procedure argument or
 be any of the following:

  o  An intrinsic function

  o  An internal function

  o  A statement function

  o  Defined as RECURSIVE


 A variable in a specification expression must have its type and
 type parameters (if any) specified in one of the following ways:

  o  By a previous declaration in the same scoping unit

  o  By the implicit typing rules currently in effect for the
     scoping unit

  o  By host or use association


 If a variable in a specification expression is typed by the
 implicit typing rules, its appearance in any subsequent type
 declaration statement must confirm the implied type and type
 parameters.

 If a specification expression invokes an inquiry function for a
 type parameter or an array bound of an object, the type parameter
 or array bound must be specified in a prior specification statement
 (or to the left of the inquiry function in the same statement).