调用序列不兼容的 Fortran 77 代码 - 如何在 Fortran 90/95 中模块化？

Question

考虑以下“现实世界”的遗留 Fortran 77 代码，根据标准，它很可能是非法的，但在现实生活中适用于各种编译器，并且如果每个子例程单独编译，则不会产生编译器或链接器警告.

subroutine a
complex z(10)
call b(z)
call r1(z)
call r2(z)
end

subroutine b(z)
complex z(10)
c ... use complex arithmetic on z
end

subroutine r1(x)
real x(2,10)
c ... do something with real and imaginary parts
c ... real parts are x(1,*)
c ... imaginary parts are x(2,*)
end

subroutine r2(x)
real x(20)
c ... do something with real and imaginary parts
end

我想使用 Fortran 90/95 模块以这种风格重新打包代码。

的幼稚方法

module m
public a
private b, r1, r2
contains 

subroutine a
complex z(10)
call b(z)
call r1(z)
call r2(z) 
end subroutine a

subroutine b(z)
complex z(10)
c ... use complex arithmetic on z
end subroutine b

subroutine r1(x)
real x(2,10)
c ... do something with real and imaginary parts
c ... real parts are x(1,*)
c ... imaginary parts are x(2,*)
end subroutine r1

subroutine r2(x)
real x(20)
c ... do something with real and imaginary parts
end subroutine r2

end module m

不编译，因为（当然）编译器现在可以看到子例程 r1 和 r2 使用错误的参数类型调用。

我需要一些关于如何解决这个问题的想法，只需对现有代码进行最少的重写，并且不复制内存中的数据 - 数据的真实大小太大了。

Answer 1

c_f_pointer() 可能有助于获取指向complex(*) 数组的real(2,*) 指针，但我不确定是否将复杂参数 (zconst(:)) 传递给 ctor() 是否真的可以......（这里我使用了 gfortran 4.4 & 4.8 和 ifort 14.0，为了使输出更紧凑，数组维度从 10 更改为 3。）

module m
    implicit none
contains

subroutine r1 ( x )
    real x( 2, 3 )

    print *
    print *, "In r1:"
    print *, "Real part = ",x( 1, : )
    print *, "Imag part = ",x( 2, : )
endsubroutine

subroutine r2 ( x )
    real x( 6 )

    print *
    print *, "In r2:"
    print *, "all elements = ", x( : )
endsubroutine

subroutine b ( z )
    complex :: z( 3 )
    real, pointer :: rp(:,:)

    rp => ctor( z, 3 )  !! to compare z and rp                                      
    print *
    print *, "In b:"
    print *, "1st elem = ", z( 1 ), rp( :, 1 )
    print *, "3rd elem = ", z( 3 ), rp( :, 3 )
endsubroutine

function ctor( z, n ) result( ret )   !! get real(2,*) pointer to complex(*)
    use iso_c_binding
    implicit none
    integer :: n
    complex, target :: z( n )
    real, pointer :: ret(:,:)
    call c_f_pointer( c_loc(z(1)), ret, shape=[2,n] )
endfunction

endmodule

program main
    use m
    implicit none
    complex z(3)
    complex, parameter :: zconst(3) = [(7.0,-7.0),(8.0,-8.0),(9.0,-9.0)]

    z(1) = ( 1.0, -1.0 )
    z(2) = ( 2.0, -2.0 )
    z(3) = ( 3.0, -3.0 )

    call r1 ( ctor( z, 3 ) )
    call r1 ( ctor( zconst, 3 ) )

    call r2 ( ctor( z, 3 ) )
    call r2 ( ctor( zconst, 3 ) )

    call b ( z )
    call b ( zconst )
 endprogram

Answer 2

请注意，以下建议有一些倒退的方面。

在问题的示例代码中，数据的原始来源是一个局部变量。这样的局部变量可以通过使用等价语句出现在存储关联上下文中，并且在这样的上下文中可以将 COMPLEX 对象视为一对 REAL 对象。

module m
  public a
  private b, r1, r2
contains 
  subroutine a
    complex z(10)
    real r(size(z)*2)
    equivalence (z,r)
    call b(z)     ! pass complex array
    call r1(r)    ! pass real array
    call r2(r)    ! pass real  array
  end subroutine a

  subroutine b(z)
    complex z(10)
    ! ... use complex arithmetic on z
  end subroutine b

  subroutine r1(x)
    real x(2,10)
    ! ... do something with real and imaginary parts
    ! ... real parts are x(1,*)
    ! ... imaginary parts are x(2,*)
  end subroutine r1

  subroutine r2(x)
    real x(20)
    ! ... do something with real and imaginary parts
  end subroutine r2
end module m

Answer 3

（这可能更像是一个评论而不是一个答案，但你不能在评论中包含格式化的代码）。

@roygvib 在标准 fortran 2003 中回答了这个问题。

可以使用许多编译器中实现的非标准“Cray Fortran 指针”语法更简洁地编码相同的想法 - 例如 gfortran 中的 -fcray-pointer 选项。非标准内部函数loc 替换ctor。

subroutine b ( z )
    complex :: z( 3 )

    real :: r( 2, 3 )
    pointer(zp, r)
    zp = loc(z)

    print *
    print *, "In b:"
    print *, "1st elem = ", z( 1 ), r( :, 1)
    print *, "3rd elem = ", z( 3 ), r( :, 3)
endsubroutine