COMMON /INS/B(100)
  REAL S(100), T(100)
  ...
  CALL SUB(S,T,S,B,100)
  ...
  SUBROUTINE SUB(X,Y,Z,H,N)
  REAL X(N),Y(N),Z(N),H(N)
  COMMON /INS/B(100)
  ...

dummy

伪子程序参数既可以互为别名，也可以作为全局变量的别名。 

no%dummy

遵循 Fortran 标准，伪参数在实际调用中既不互为别名也不作为全局变量的别名。（这是缺省情况。） 

craypointer

程序使用可指向任何地址的 Cray 指针。（这是缺省情况。） 

no%craypointer

Cray 指针总是指向明确的内存区，或者不被使用。 

ftnpointer

任何 Fortran 95 指针都可以指向任一目标变量，而不管其为何类型、种类或等级。 

no%ftnpointer

Fortran 95 指针遵守标准规则。（这是缺省情况。） 

overindex

在数组引用中违反下标边界可造成四种索引越界情况，其中的任何一种或多种都可以在程序中出现： 

• 对 COMMON 块中数组元素的引用可以引用 COMMON 块或等价组中的任何元素。

• 作为子程序的实际参数传递 COMMON 块或等价组的某一元素，将允许对该 COMMON 块或等价组中的任何元素进行访问。

• 会将序列派生类型的变量当作是 COMMON 块一样来看待，并且此种变量的元素可以作为该变量其他元素的别名。

• 可以违反各个数组下标边界，即使数组引用仍在该数组内。

  overindex 不适用于数组语法、WHERE 和 FORALL 语句。如果索引越界出现在这些构造中，应将它们改写为 DO 循环。

no%overindex

不违反数组边界。数组引用不引用其他变量。（这是缺省情况。） 

actual

编译器将子程序的实际参数视为全局变量。向子程序传递参数有可能通过 Cray 指针导致别名使用。 

no%actual

向子程序传递参数不会进一步造成别名使用。（这是缺省情况。） 

parameter (n=100)
integer a(n)
common /qq/z(n)
call sub(a,a,z,n)
...
subroutine sub(a,b,c,n)
integer a(n), b(n)
common /qq/z(n)
a(2:n) = b(1:n-1)
c(2:n) = z(1:n-1)
编译器必须假设伪变量和公用变量可以重叠。

parameter (n=20)
integer a(n)
integer v1(*), v2(*)
pointer (p1,v1)
pointer (p2,v2)
p1 = loc(a)
p2 = loc(a)
a = (/ (i,i=1,n) /)
...
v1(2:n) = v2(1:n-1)
编译器必须假设这些位置可以重叠。

parameter (n=10)
integer a(n+n)
integer v1(n), v2(n)
pointer (p1,v1)
pointer (p2,v2)
p1 = loc(a(1))
p2 = loc(a(n+1))
...
v1(:) = v2(:)
Cray 指针不指向重叠内存区。

parameter (n=20)
integer, pointer :: a(:)
integer, target :: t(n)
interface
  subroutine sub(a,b,n)
    integer, pointer :: a(:)
    integer, pointer :: b(:)
  end subroutine
end interface

a => t
a = (/ (i, i=1,n) /)
call sub(a,a,n)
....
end
subroutine sub(a,b,n)
 integer, pointer :: a(:)
 real, pointer :: b(:)
 integer i, mold

 forall (i=2:n)
   a(i) = transfer(b(i-1), mold)
编译器必须假设 a 和 b 可以重叠。

integer a,z
common // a(100),z
z = 1
call sub(a)
print*, z
subroutine sub(x)
  integer x(10)
  x(101) = 2
编译器假设对 sub 的调用可以写入 z
用 -xalias=overindex 编译时，程序打印 2 而非 1

本例中数组语法索引越界不会产生正确的结果！

   parameter (n=10)
   integer a(n),b(n)
   common /qq/a,b
   integer c(n)
   integer m, k
   a = (/ (i,i=1,n) /)
   b = a
   c(1) = 1
   c(2:n) = (/ (i,i=1,n-1) /)

   m = n
   k = n + n
C
C   the reference to a is actually a reference into b
C   so this should really be  b(2:n) = b(1:n-1)
C
   a(m+2:k) = b(1:n-1)

C  or doing it in reverse
   a(k:m+2:-1) = b(n-1:1:-1)

从直观上，用户期望数组 b 现在与数组 c 相似，但结果是无法预料的

 program foo
      integer i
      call take_loc(i)
      i = 1
      print * , i
      call use_loc()
      print * , i
   end

   subroutine take_loc(i)
      integer i
      common /loc_comm/ loc_i
      loc_i = loc(i)
   end subroutine take_loc

   subroutine use_loc()
      integer vi1
      pointer (pi,vi)
      common /loc_comm/ loc_i
      pi = loc_i
      vi1 = 3
   end subroutine use_loc